// =================================================================
//
//                           * WARNING *
//
//                    This file is generated!
//
//  Changes made to this file will be overwritten. If changes are
//  required to the generated code, the service_crategen project
//  must be updated to generate the changes.
//
// =================================================================

use std::error::Error;
use std::fmt;

use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};

use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};

impl SageMakerClient {
    fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
        let mut request = SignedRequest::new(http_method, "sagemaker", &self.region, request_uri);
        request.set_endpoint_prefix("api.sagemaker".to_string());

        request.set_content_type("application/x-amz-json-1.1".to_owned());

        request
    }

    async fn sign_and_dispatch<E>(
        &self,
        request: SignedRequest,
        from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
    ) -> Result<HttpResponse, RusotoError<E>> {
        let mut response = self.client.sign_and_dispatch(request).await?;
        if !response.status.is_success() {
            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
            return Err(from_response(response));
        }

        Ok(response)
    }
}

use serde_json;
/// <p>A structure describing the source of an action.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ActionSource {
    /// <p>The ID of the source.</p>
    #[serde(rename = "SourceId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_id: Option<String>,
    /// <p>The type of the source.</p>
    #[serde(rename = "SourceType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_type: Option<String>,
    /// <p>The URI of the source.</p>
    #[serde(rename = "SourceUri")]
    pub source_uri: String,
}

/// <p>Lists the properties of an <i>action</i>. 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.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ActionSummary {
    /// <p>The Amazon Resource Name (ARN) of the action.</p>
    #[serde(rename = "ActionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub action_arn: Option<String>,
    /// <p>The name of the action.</p>
    #[serde(rename = "ActionName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub action_name: Option<String>,
    /// <p>The type of the action.</p>
    #[serde(rename = "ActionType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub action_type: Option<String>,
    /// <p>When the action was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>When the action was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The source of the action.</p>
    #[serde(rename = "Source")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<ActionSource>,
    /// <p>The status of the action.</p>
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddAssociationRequest {
    /// <p><p>The type of association. The following are suggested uses for each type. Amazon SageMaker places no restrictions on their use.</p> <ul> <li> <p>ContributedTo - The source contributed to the destination or had a part in enabling the destination. For example, the training data contributed to the training job.</p> </li> <li> <p>AssociatedWith - The source is connected to the destination. For example, an approval workflow is associated with a model deployment.</p> </li> <li> <p>DerivedFrom - The destination is a modification of the source. For example, a digest output of a channel input for a processing job is derived from the original inputs.</p> </li> <li> <p>Produced - The source generated the destination. For example, a training job produced a model artifact.</p> </li> </ul></p>
    #[serde(rename = "AssociationType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub association_type: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the destination.</p>
    #[serde(rename = "DestinationArn")]
    pub destination_arn: String,
    /// <p>The ARN of the source.</p>
    #[serde(rename = "SourceArn")]
    pub source_arn: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddAssociationResponse {
    /// <p>The Amazon Resource Name (ARN) of the destination.</p>
    #[serde(rename = "DestinationArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub destination_arn: Option<String>,
    /// <p>The ARN of the source.</p>
    #[serde(rename = "SourceArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddTagsInput {
    /// <p>The Amazon Resource Name (ARN) of the resource that you want to tag.</p>
    #[serde(rename = "ResourceArn")]
    pub resource_arn: String,
    /// <p>An array of key-value pairs. You can use tags to categorize your AWS resources in different ways, for example, by purpose, owner, or environment. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS Resources</a>.</p>
    #[serde(rename = "Tags")]
    pub tags: Vec<Tag>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddTagsOutput {
    /// <p>A list of tags associated with the Amazon SageMaker resource.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

/// <p>Edge Manager agent version.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AgentVersion {
    /// <p>The number of Edge Manager agents.</p>
    #[serde(rename = "AgentCount")]
    pub agent_count: i64,
    /// <p>Version of the agent.</p>
    #[serde(rename = "Version")]
    pub version: String,
}

/// <p>This API is not supported.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Alarm {
    /// <p><p/></p>
    #[serde(rename = "AlarmName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alarm_name: Option<String>,
}

/// <p>Specifies the training algorithm to use in a <a>CreateTrainingJob</a> request.</p> <p>For more information about algorithms provided by Amazon SageMaker, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html">Algorithms</a>. For information about using your own algorithms, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms.html">Using Your Own Algorithms with Amazon SageMaker</a>. </p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AlgorithmSpecification {
    /// <p>The name of the algorithm resource to use for the training job. This must be an algorithm resource that you created or subscribe to on AWS Marketplace. If you specify a value for this parameter, you can't specify a value for <code>TrainingImage</code>.</p>
    #[serde(rename = "AlgorithmName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub algorithm_name: Option<String>,
    /// <p><p>To generate and save time-series metrics during training, set to <code>true</code>. The default is <code>false</code> and time-series metrics aren&#39;t generated except in the following cases:</p> <ul> <li> <p>You use one of the Amazon SageMaker built-in algorithms</p> </li> <li> <p>You use one of the following <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/pre-built-containers-frameworks-deep-learning.html">Prebuilt Amazon SageMaker Docker Images</a>:</p> <ul> <li> <p>Tensorflow (version &gt;= 1.15)</p> </li> <li> <p>MXNet (version &gt;= 1.6)</p> </li> <li> <p>PyTorch (version &gt;= 1.3)</p> </li> </ul> </li> <li> <p>You specify at least one <a>MetricDefinition</a> </p> </li> </ul></p>
    #[serde(rename = "EnableSageMakerMetricsTimeSeries")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_sage_maker_metrics_time_series: Option<bool>,
    /// <p>A list of metric definition objects. Each object specifies the metric name and regular expressions used to parse algorithm logs. Amazon SageMaker publishes each metric to Amazon CloudWatch.</p>
    #[serde(rename = "MetricDefinitions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metric_definitions: Option<Vec<MetricDefinition>>,
    /// <p>The registry path of the Docker image that contains the training algorithm. For information about docker registry paths for built-in algorithms, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html">Algorithms Provided by Amazon SageMaker: Common Parameters</a>. Amazon SageMaker supports both <code>registry/repository[:tag]</code> and <code>registry/repository[@digest]</code> image path formats. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms.html">Using Your Own Algorithms with Amazon SageMaker</a>.</p>
    #[serde(rename = "TrainingImage")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_image: Option<String>,
    /// <p>The input mode that the algorithm supports. For the input modes that Amazon SageMaker algorithms support, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html">Algorithms</a>. If an algorithm supports the <code>File</code> input mode, Amazon SageMaker downloads the training data from S3 to the provisioned ML storage Volume, and mounts the directory to docker volume for training container. If an algorithm supports the <code>Pipe</code> input mode, Amazon SageMaker streams data directly from S3 to the container. </p> <p> In File mode, make sure you provision ML storage volume with sufficient capacity to accommodate the data download from S3. In addition to the training data, the ML storage volume also stores the output model. The algorithm container use ML storage volume to also store intermediate information, if any. </p> <p> For distributed algorithms using File mode, training data is distributed uniformly, and your training duration is predictable if the input data objects size is approximately same. Amazon SageMaker does not split the files any further for model training. If the object sizes are skewed, training won't be optimal as the data distribution is also skewed where one host in a training cluster is overloaded, thus becoming bottleneck in training. </p>
    #[serde(rename = "TrainingInputMode")]
    pub training_input_mode: String,
}

/// <p>Specifies the validation and image scan statuses of the algorithm.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AlgorithmStatusDetails {
    /// <p>The status of the scan of the algorithm's Docker image container.</p>
    #[serde(rename = "ImageScanStatuses")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_scan_statuses: Option<Vec<AlgorithmStatusItem>>,
    /// <p>The status of algorithm validation.</p>
    #[serde(rename = "ValidationStatuses")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub validation_statuses: Option<Vec<AlgorithmStatusItem>>,
}

/// <p>Represents the overall status of an algorithm.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AlgorithmStatusItem {
    /// <p>if the overall status is <code>Failed</code>, the reason for the failure.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The name of the algorithm for which the overall status is being reported.</p>
    #[serde(rename = "Name")]
    pub name: String,
    /// <p>The current status.</p>
    #[serde(rename = "Status")]
    pub status: String,
}

/// <p>Provides summary information about an algorithm.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AlgorithmSummary {
    /// <p>The Amazon Resource Name (ARN) of the algorithm.</p>
    #[serde(rename = "AlgorithmArn")]
    pub algorithm_arn: String,
    /// <p>A brief description of the algorithm.</p>
    #[serde(rename = "AlgorithmDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub algorithm_description: Option<String>,
    /// <p>The name of the algorithm that is described by the summary.</p>
    #[serde(rename = "AlgorithmName")]
    pub algorithm_name: String,
    /// <p>The overall status of the algorithm.</p>
    #[serde(rename = "AlgorithmStatus")]
    pub algorithm_status: String,
    /// <p>A timestamp that shows when the algorithm was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
}

/// <p>Defines a training job and a batch transform job that Amazon SageMaker runs to validate your algorithm.</p> <p>The data provided in the validation profile is made available to your buyers on AWS Marketplace.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AlgorithmValidationProfile {
    /// <p>The name of the profile for the algorithm. The name must have 1 to 63 characters. Valid characters are a-z, A-Z, 0-9, and - (hyphen).</p>
    #[serde(rename = "ProfileName")]
    pub profile_name: String,
    /// <p>The <code>TrainingJobDefinition</code> object that describes the training job that Amazon SageMaker runs to validate your algorithm.</p>
    #[serde(rename = "TrainingJobDefinition")]
    pub training_job_definition: TrainingJobDefinition,
    /// <p>The <code>TransformJobDefinition</code> object that describes the transform job that Amazon SageMaker runs to validate your algorithm.</p>
    #[serde(rename = "TransformJobDefinition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transform_job_definition: Option<TransformJobDefinition>,
}

/// <p>Specifies configurations for one or more training jobs that Amazon SageMaker runs to test the algorithm.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AlgorithmValidationSpecification {
    /// <p>An array of <code>AlgorithmValidationProfile</code> objects, each of which specifies a training job and batch transform job that Amazon SageMaker runs to validate your algorithm.</p>
    #[serde(rename = "ValidationProfiles")]
    pub validation_profiles: Vec<AlgorithmValidationProfile>,
    /// <p>The IAM roles that Amazon SageMaker uses to run the training jobs.</p>
    #[serde(rename = "ValidationRole")]
    pub validation_role: String,
}

/// <p>Configures how labels are consolidated across human workers and processes output data. </p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AnnotationConsolidationConfig {
    /// <p><p>The Amazon Resource Name (ARN) of a Lambda function implements the logic for <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-annotation-consolidation.html">annotation consolidation</a> and to process output data.</p> <p>This parameter is required for all labeling jobs. For <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-task-types.html">built-in task types</a>, use one of the following Amazon SageMaker Ground Truth Lambda function ARNs for <code>AnnotationConsolidationLambdaArn</code>. For custom labeling workflows, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-custom-templates-step3.html#sms-custom-templates-step3-postlambda">Post-annotation Lambda</a>. </p> <p> <b>Bounding box</b> - Finds the most similar boxes from different workers based on the Jaccard index of the boxes.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-BoundingBox</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-BoundingBox</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-BoundingBox</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-BoundingBox</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-BoundingBox</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-BoundingBox</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-BoundingBox</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-BoundingBox</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-BoundingBox</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-BoundingBox</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-BoundingBox</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-BoundingBox</code> </p> </li> </ul> <p> <b>Image classification</b> - Uses a variant of the Expectation Maximization approach to estimate the true class of an image based on annotations from individual workers.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-ImageMultiClass</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-ImageMultiClass</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-ImageMultiClass</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-ImageMultiClass</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-ImageMultiClass</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-ImageMultiClass</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-ImageMultiClass</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-ImageMultiClass</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-ImageMultiClass</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-ImageMultiClass</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-ImageMultiClass</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-ImageMultiClass</code> </p> </li> </ul> <p> <b>Multi-label image classification</b> - Uses a variant of the Expectation Maximization approach to estimate the true classes of an image based on annotations from individual workers.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-ImageMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-ImageMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-ImageMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-ImageMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-ImageMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-ImageMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-ImageMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-ImageMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-ImageMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-ImageMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-ImageMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-ImageMultiClassMultiLabel</code> </p> </li> </ul> <p> <b>Semantic segmentation</b> - Treats each pixel in an image as a multi-class classification and treats pixel annotations from workers as &quot;votes&quot; for the correct label.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-SemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-SemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-SemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-SemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-SemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-SemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-SemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-SemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-SemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-SemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-SemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-SemanticSegmentation</code> </p> </li> </ul> <p> <b>Text classification</b> - Uses a variant of the Expectation Maximization approach to estimate the true class of text based on annotations from individual workers.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-TextMultiClass</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-TextMultiClass</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-TextMultiClass</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-TextMultiClass</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-TextMultiClass</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-TextMultiClass</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-TextMultiClass</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-TextMultiClass</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-TextMultiClass</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-TextMultiClass</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-TextMultiClass</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-TextMultiClass</code> </p> </li> </ul> <p> <b>Multi-label text classification</b> - Uses a variant of the Expectation Maximization approach to estimate the true classes of text based on annotations from individual workers.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-TextMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-TextMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-TextMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-TextMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-TextMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-TextMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-TextMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-TextMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-TextMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-TextMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-TextMultiClassMultiLabel</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-TextMultiClassMultiLabel</code> </p> </li> </ul> <p> <b>Named entity recognition</b> - Groups similar selections and calculates aggregate boundaries, resolving to most-assigned label.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-NamedEntityRecognition</code> </p> </li> </ul> <p> <b>Named entity recognition</b> - Groups similar selections and calculates aggregate boundaries, resolving to most-assigned label.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-NamedEntityRecognition</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-NamedEntityRecognition</code> </p> </li> </ul> <p> <b>Video Classification</b> - Use this task type when you need workers to classify videos using predefined labels that you specify. Workers are shown videos and are asked to choose one label for each video.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-VideoMultiClass</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-VideoMultiClass</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-VideoMultiClass</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-VideoMultiClass</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-VideoMultiClass</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-VideoMultiClass</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-VideoMultiClass</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-VideoMultiClass</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-VideoMultiClass</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-VideoMultiClass</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-VideoMultiClass</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-VideoMultiClass</code> </p> </li> </ul> <p> <b>Video Frame Object Detection</b> - Use this task type to have workers identify and locate objects in a sequence of video frames (images extracted from a video) using bounding boxes. For example, you can use this task to ask workers to identify and localize various objects in a series of video frames, such as cars, bikes, and pedestrians.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-VideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-VideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-VideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-VideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-VideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-VideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-VideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-VideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-VideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-VideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-VideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-VideoObjectDetection</code> </p> </li> </ul> <p> <b>Video Frame Object Tracking</b> - Use this task type to have workers track the movement of objects in a sequence of video frames (images extracted from a video) using bounding boxes. For example, you can use this task to ask workers to track the movement of objects, such as cars, bikes, and pedestrians. </p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-VideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-VideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-VideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-VideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-VideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-VideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-VideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-VideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-VideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-VideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-VideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-VideoObjectTracking</code> </p> </li> </ul> <p> <b>3D point cloud object detection</b> - Use this task type when you want workers to classify objects in a 3D point cloud by drawing 3D cuboids around objects. For example, you can use this task type to ask workers to identify different types of objects in a point cloud, such as cars, bikes, and pedestrians.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-3DPointCloudObjectDetection</code> </p> </li> </ul> <p> <b>3D point cloud object tracking</b> - Use this task type when you want workers to draw 3D cuboids around objects that appear in a sequence of 3D point cloud frames. For example, you can use this task type to ask workers to track the movement of vehicles across multiple point cloud frames. </p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-3DPointCloudObjectTracking</code> </p> </li> </ul> <p> <b>3D point cloud semantic segmentation</b> - Use this task type when you want workers to create a point-level semantic segmentation masks by painting objects in a 3D point cloud using different colors where each color is assigned to one of the classes you specify.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-3DPointCloudSemanticSegmentation</code> </p> </li> </ul> <p> <b>Use the following ARNs for Label Verification and Adjustment Jobs</b> </p> <p>Use label verification and adjustment jobs to review and adjust labels. To learn more, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-verification-data.html">Verify and Adjust Labels </a>.</p> <p> <b>Semantic segmentation adjustment</b> - Treats each pixel in an image as a multi-class classification and treats pixel adjusted annotations from workers as &quot;votes&quot; for the correct label.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-AdjustmentSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-AdjustmentSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-AdjustmentSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-AdjustmentSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-AdjustmentSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-AdjustmentSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-AdjustmentSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-AdjustmentSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-AdjustmentSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-AdjustmentSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-AdjustmentSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-AdjustmentSemanticSegmentation</code> </p> </li> </ul> <p> <b>Semantic segmentation verification</b> - Uses a variant of the Expectation Maximization approach to estimate the true class of verification judgment for semantic segmentation labels based on annotations from individual workers.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-VerificationSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-VerificationSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-VerificationSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-VerificationSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-VerificationSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-VerificationSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-VerificationSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-VerificationSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-VerificationSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-VerificationSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-VerificationSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-VerificationSemanticSegmentation</code> </p> </li> </ul> <p> <b>Bounding box verification</b> - Uses a variant of the Expectation Maximization approach to estimate the true class of verification judgement for bounding box labels based on annotations from individual workers.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-VerificationBoundingBox</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-VerificationBoundingBox</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-VerificationBoundingBox</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-VerificationBoundingBox</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-VerificationBoundingBox</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-VerificationBoundingBox</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-VerificationBoundingBox</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-VerificationBoundingBox</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-VerificationBoundingBox</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-VerificationBoundingBox</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-VerificationBoundingBox</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-VerificationBoundingBox</code> </p> </li> </ul> <p> <b>Bounding box adjustment</b> - Finds the most similar boxes from different workers based on the Jaccard index of the adjusted annotations.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-AdjustmentBoundingBox</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-AdjustmentBoundingBox</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-AdjustmentBoundingBox</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-AdjustmentBoundingBox</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-AdjustmentBoundingBox</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-AdjustmentBoundingBox</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-AdjustmentBoundingBox</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-AdjustmentBoundingBox</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-AdjustmentBoundingBox</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-AdjustmentBoundingBox</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-AdjustmentBoundingBox</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-AdjustmentBoundingBox</code> </p> </li> </ul> <p> <b>Video Frame Object Detection Adjustment</b> - Use this task type when you want workers to adjust bounding boxes that workers have added to video frames to classify and localize objects in a sequence of video frames.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-AdjustmentVideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-AdjustmentVideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-AdjustmentVideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-AdjustmentVideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-AdjustmentVideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-AdjustmentVideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-AdjustmentVideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-AdjustmentVideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-AdjustmentVideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-AdjustmentVideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-AdjustmentVideoObjectDetection</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-AdjustmentVideoObjectDetection</code> </p> </li> </ul> <p> <b>Video Frame Object Tracking Adjustment</b> - Use this task type when you want workers to adjust bounding boxes that workers have added to video frames to track object movement across a sequence of video frames.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-AdjustmentVideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-AdjustmentVideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-AdjustmentVideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-AdjustmentVideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-AdjustmentVideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-AdjustmentVideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-AdjustmentVideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-AdjustmentVideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-AdjustmentVideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-AdjustmentVideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-AdjustmentVideoObjectTracking</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-AdjustmentVideoObjectTracking</code> </p> </li> </ul> <p> <b>3D point cloud object detection adjustment</b> - Use this task type when you want workers to adjust 3D cuboids around objects in a 3D point cloud. </p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-Adjustment3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-Adjustment3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-Adjustment3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-Adjustment3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-Adjustment3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-Adjustment3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-Adjustment3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-Adjustment3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-Adjustment3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-Adjustment3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-Adjustment3DPointCloudObjectDetection</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-Adjustment3DPointCloudObjectDetection</code> </p> </li> </ul> <p> <b>3D point cloud object tracking adjustment</b> - Use this task type when you want workers to adjust 3D cuboids around objects that appear in a sequence of 3D point cloud frames.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-Adjustment3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-Adjustment3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-Adjustment3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-Adjustment3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-Adjustment3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-Adjustment3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-Adjustment3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-Adjustment3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-Adjustment3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-Adjustment3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-Adjustment3DPointCloudObjectTracking</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-Adjustment3DPointCloudObjectTracking</code> </p> </li> </ul> <p> <b>3D point cloud semantic segmentation adjustment</b> - Use this task type when you want workers to adjust a point-level semantic segmentation masks using a paint tool.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:ACS-Adjustment3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:ACS-Adjustment3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:ACS-Adjustment3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:ACS-Adjustment3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:ACS-Adjustment3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:ACS-Adjustment3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:ACS-Adjustment3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:ACS-Adjustment3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:ACS-Adjustment3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:ACS-Adjustment3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:ACS-Adjustment3DPointCloudSemanticSegmentation</code> </p> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:ACS-Adjustment3DPointCloudSemanticSegmentation</code> </p> </li> </ul></p>
    #[serde(rename = "AnnotationConsolidationLambdaArn")]
    pub annotation_consolidation_lambda_arn: String,
}

/// <p>Details about an Amazon SageMaker app.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AppDetails {
    /// <p>The name of the app.</p>
    #[serde(rename = "AppName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_name: Option<String>,
    /// <p>The type of app.</p>
    #[serde(rename = "AppType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_type: Option<String>,
    /// <p>The creation time.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The domain ID.</p>
    #[serde(rename = "DomainId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_id: Option<String>,
    /// <p>The status.</p>
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    /// <p>The user profile name.</p>
    #[serde(rename = "UserProfileName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_profile_name: Option<String>,
}

/// <p>The configuration for running a SageMaker image as a KernelGateway app.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AppImageConfigDetails {
    /// <p>The Amazon Resource Name (ARN) of the AppImageConfig.</p>
    #[serde(rename = "AppImageConfigArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_image_config_arn: Option<String>,
    /// <p>The name of the AppImageConfig. Must be unique to your account.</p>
    #[serde(rename = "AppImageConfigName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_image_config_name: Option<String>,
    /// <p>When the AppImageConfig was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The configuration for the file system and kernels in the SageMaker image.</p>
    #[serde(rename = "KernelGatewayImageConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kernel_gateway_image_config: Option<KernelGatewayImageConfig>,
    /// <p>When the AppImageConfig was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
}

/// <p>Configuration to run a processing job in a specified container image.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AppSpecification {
    /// <p>The arguments for a container used to run a processing job.</p>
    #[serde(rename = "ContainerArguments")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_arguments: Option<Vec<String>>,
    /// <p>The entrypoint for a container used to run a processing job.</p>
    #[serde(rename = "ContainerEntrypoint")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_entrypoint: Option<Vec<String>>,
    /// <p>The container image to be run by the processing job.</p>
    #[serde(rename = "ImageUri")]
    pub image_uri: String,
}

/// <p>A structure describing the source of an artifact.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ArtifactSource {
    /// <p>A list of source types.</p>
    #[serde(rename = "SourceTypes")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_types: Option<Vec<ArtifactSourceType>>,
    /// <p>The URI of the source.</p>
    #[serde(rename = "SourceUri")]
    pub source_uri: String,
}

/// <p>The ID and ID type of an artifact source.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ArtifactSourceType {
    /// <p>The type of ID.</p>
    #[serde(rename = "SourceIdType")]
    pub source_id_type: String,
    /// <p>The ID.</p>
    #[serde(rename = "Value")]
    pub value: String,
}

/// <p>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.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ArtifactSummary {
    /// <p>The Amazon Resource Name (ARN) of the artifact.</p>
    #[serde(rename = "ArtifactArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artifact_arn: Option<String>,
    /// <p>The name of the artifact.</p>
    #[serde(rename = "ArtifactName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artifact_name: Option<String>,
    /// <p>The type of the artifact.</p>
    #[serde(rename = "ArtifactType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artifact_type: Option<String>,
    /// <p>When the artifact was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>When the artifact was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The source of the artifact.</p>
    #[serde(rename = "Source")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<ArtifactSource>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateTrialComponentRequest {
    /// <p>The name of the component to associated with the trial.</p>
    #[serde(rename = "TrialComponentName")]
    pub trial_component_name: String,
    /// <p>The name of the trial to associate with.</p>
    #[serde(rename = "TrialName")]
    pub trial_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateTrialComponentResponse {
    /// <p>The Amazon Resource Name (ARN) of the trial.</p>
    #[serde(rename = "TrialArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_arn: Option<String>,
    /// <p>The ARN of the trial component.</p>
    #[serde(rename = "TrialComponentArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_arn: Option<String>,
}

/// <p>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.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociationSummary {
    /// <p>The type of the association.</p>
    #[serde(rename = "AssociationType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub association_type: Option<String>,
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>When the association was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the destination.</p>
    #[serde(rename = "DestinationArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub destination_arn: Option<String>,
    /// <p>The name of the destination.</p>
    #[serde(rename = "DestinationName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub destination_name: Option<String>,
    /// <p>The destination type.</p>
    #[serde(rename = "DestinationType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub destination_type: Option<String>,
    /// <p>The ARN of the source.</p>
    #[serde(rename = "SourceArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_arn: Option<String>,
    /// <p>The name of the source.</p>
    #[serde(rename = "SourceName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_name: Option<String>,
    /// <p>The source type.</p>
    #[serde(rename = "SourceType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_type: Option<String>,
}

/// <p>Configuration for Athena Dataset Definition input.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AthenaDatasetDefinition {
    #[serde(rename = "Catalog")]
    pub catalog: String,
    #[serde(rename = "Database")]
    pub database: String,
    /// <p>The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt data generated from an Athena query execution.</p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    #[serde(rename = "OutputCompression")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_compression: Option<String>,
    #[serde(rename = "OutputFormat")]
    pub output_format: String,
    /// <p>The location in Amazon S3 where Athena query results are stored.</p>
    #[serde(rename = "OutputS3Uri")]
    pub output_s3_uri: String,
    #[serde(rename = "QueryString")]
    pub query_string: String,
    #[serde(rename = "WorkGroup")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub work_group: Option<String>,
}

/// <p>An Autopilot job returns recommendations, or candidates. Each candidate has futher details about the steps involed, and the status.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AutoMLCandidate {
    /// <p>The candidate name.</p>
    #[serde(rename = "CandidateName")]
    pub candidate_name: String,
    /// <p>The candidate's status.</p>
    #[serde(rename = "CandidateStatus")]
    pub candidate_status: String,
    /// <p>The candidate's steps.</p>
    #[serde(rename = "CandidateSteps")]
    pub candidate_steps: Vec<AutoMLCandidateStep>,
    /// <p>The creation time.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The end time.</p>
    #[serde(rename = "EndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub end_time: Option<f64>,
    /// <p>The failure reason.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    #[serde(rename = "FinalAutoMLJobObjectiveMetric")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub final_auto_ml_job_objective_metric: Option<FinalAutoMLJobObjectiveMetric>,
    /// <p>The inference containers.</p>
    #[serde(rename = "InferenceContainers")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inference_containers: Option<Vec<AutoMLContainerDefinition>>,
    /// <p>The last modified time.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
    /// <p>The objective status.</p>
    #[serde(rename = "ObjectiveStatus")]
    pub objective_status: String,
}

/// <p>Information about the steps for a Candidate, and what step it is working on.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AutoMLCandidateStep {
    /// <p>The ARN for the Candidate's step.</p>
    #[serde(rename = "CandidateStepArn")]
    pub candidate_step_arn: String,
    /// <p>The name for the Candidate's step.</p>
    #[serde(rename = "CandidateStepName")]
    pub candidate_step_name: String,
    /// <p>Whether the Candidate is at the transform, training, or processing step.</p>
    #[serde(rename = "CandidateStepType")]
    pub candidate_step_type: String,
}

/// <p>Similar to Channel. A channel is a named input source that training algorithms can consume. Refer to Channel for detailed descriptions.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AutoMLChannel {
    /// <p>You can use Gzip or None. The default value is None.</p>
    #[serde(rename = "CompressionType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub compression_type: Option<String>,
    /// <p>The data source.</p>
    #[serde(rename = "DataSource")]
    pub data_source: AutoMLDataSource,
    /// <p>The name of the target variable in supervised learning, a.k.a. 'y'.</p>
    #[serde(rename = "TargetAttributeName")]
    pub target_attribute_name: String,
}

/// <p>A list of container definitions that describe the different containers that make up one AutoML candidate. Refer to ContainerDefinition for more details.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AutoMLContainerDefinition {
    /// <p>Environment variables to set in the container. Refer to ContainerDefinition for more details.</p>
    #[serde(rename = "Environment")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub environment: Option<::std::collections::HashMap<String, String>>,
    /// <p>The ECR path of the container. Refer to ContainerDefinition for more details.</p>
    #[serde(rename = "Image")]
    pub image: String,
    /// <p>The location of the model artifacts. Refer to ContainerDefinition for more details.</p>
    #[serde(rename = "ModelDataUrl")]
    pub model_data_url: String,
}

/// <p>The data source for the Autopilot job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AutoMLDataSource {
    /// <p><p>The Amazon S3 location of the input data.</p> <note> <p>The input data must be in CSV format and contain at least 500 rows.</p> </note></p>
    #[serde(rename = "S3DataSource")]
    pub s3_data_source: AutoMLS3DataSource,
}

/// <p>Artifacts that are generation during a job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AutoMLJobArtifacts {
    /// <p>The URL to the notebook location.</p>
    #[serde(rename = "CandidateDefinitionNotebookLocation")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub candidate_definition_notebook_location: Option<String>,
    /// <p>The URL to the notebook location.</p>
    #[serde(rename = "DataExplorationNotebookLocation")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data_exploration_notebook_location: Option<String>,
}

/// <p>How long a job is allowed to run, or how many candidates a job is allowed to generate.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AutoMLJobCompletionCriteria {
    /// <p>The maximum time, in seconds, an AutoML job is allowed to wait for a trial to complete. It must be equal to or greater than MaxRuntimePerTrainingJobInSeconds.</p>
    #[serde(rename = "MaxAutoMLJobRuntimeInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_auto_ml_job_runtime_in_seconds: Option<i64>,
    /// <p>The maximum number of times a training job is allowed to run.</p>
    #[serde(rename = "MaxCandidates")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_candidates: Option<i64>,
    /// <p>The maximum time, in seconds, a job is allowed to run.</p>
    #[serde(rename = "MaxRuntimePerTrainingJobInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_runtime_per_training_job_in_seconds: Option<i64>,
}

/// <p>A collection of settings used for a job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AutoMLJobConfig {
    /// <p>How long a job is allowed to run, or how many candidates a job is allowed to generate.</p>
    #[serde(rename = "CompletionCriteria")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub completion_criteria: Option<AutoMLJobCompletionCriteria>,
    /// <p>Security configuration for traffic encryption or Amazon VPC settings.</p>
    #[serde(rename = "SecurityConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub security_config: Option<AutoMLSecurityConfig>,
}

/// <p>Specifies a metric to minimize or maximize as the objective of a job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AutoMLJobObjective {
    /// <p><p>The name of the objective metric used to measure the predictive quality of a machine learning system. This metric is optimized during training to provide the best estimate for model parameter values from data.</p> <p>Here are the options:</p> <ul> <li> <p> <code>MSE</code>: The mean squared error (MSE) is the average of the squared differences between the predicted and actual values. It is used for regression. MSE values are always positive, the better a model is at predicting the actual values the smaller the MSE value. When the data contains outliers, they tend to dominate the MSE which might cause subpar prediction performance.</p> </li> <li> <p> <code>Accuracy</code>: The ratio of the number correctly classified items to the total number (correctly and incorrectly) classified. It is used for binary and multiclass classification. Measures how close the predicted class values are to the actual values. Accuracy values vary between zero and one, one being perfect accuracy and zero perfect inaccuracy.</p> </li> <li> <p> <code>F1</code>: The F1 score is the harmonic mean of the precision and recall. It is used for binary classification into classes traditionally referred to as positive and negative. Predictions are said to be true when they match their actual (correct) class; false when they do not. Precision is the ratio of the true positive predictions to all positive predictions (including the false positives) in a data set and measures the quality of the prediction when it predicts the positive class. Recall (or sensitivity) is the ratio of the true positive predictions to all actual positive instances and measures how completely a model predicts the actual class members in a data set. The standard F1 score weighs precision and recall equally. But which metric is paramount typically depends on specific aspects of a problem. F1 scores vary between zero and one, one being the best possible performance and zero the worst.</p> </li> <li> <p> <code>AUC</code>: The area under the curve (AUC) metric is used to compare and evaluate binary classification by algorithms such as logistic regression that return probabilities. A threshold is needed to map the probabilities into classifications. The relevant curve is the receiver operating characteristic curve that plots the true positive rate (TPR) of predictions (or recall) against the false positive rate (FPR) as a function of the threshold value, above which a prediction is considered positive. Increasing the threshold results in fewer false positives but more false negatives. AUC is the area under this receiver operating characteristic curve and so provides an aggregated measure of the model performance across all possible classification thresholds. The AUC score can also be interpreted as the probability that a randomly selected positive data point is more likely to be predicted positive than a randomly selected negative example. AUC scores vary between zero and one, one being perfect accuracy and one half not better than a random classifier. Values less that one half predict worse than a random predictor and such consistently bad predictors can be inverted to obtain better than random predictors.</p> </li> <li> <p> <code>F1macro</code>: The F1macro score applies F1 scoring to multiclass classification. In this context, you have multiple classes to predict. You just calculate the precision and recall for each class as you did for the positive class in binary classification. Then used these values to calculate the F1 score for each class and average them to obtain the F1macro score. F1macro scores vary between zero and one, one being the best possible performance and zero the worst.</p> </li> </ul> <p>If you do not specify a metric explicitly, the default behavior is to automatically use:</p> <ul> <li> <p> <code>MSE</code>: for regression.</p> </li> <li> <p> <code>F1</code>: for binary classification</p> </li> <li> <p> <code>Accuracy</code>: for multiclass classification.</p> </li> </ul></p>
    #[serde(rename = "MetricName")]
    pub metric_name: String,
}

/// <p>Provides a summary about a job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AutoMLJobSummary {
    /// <p>The ARN of the job.</p>
    #[serde(rename = "AutoMLJobArn")]
    pub auto_ml_job_arn: String,
    /// <p>The name of the object you are requesting.</p>
    #[serde(rename = "AutoMLJobName")]
    pub auto_ml_job_name: String,
    /// <p>The job's secondary status.</p>
    #[serde(rename = "AutoMLJobSecondaryStatus")]
    pub auto_ml_job_secondary_status: String,
    /// <p>The job's status.</p>
    #[serde(rename = "AutoMLJobStatus")]
    pub auto_ml_job_status: String,
    /// <p>When the job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The end time of an AutoML job.</p>
    #[serde(rename = "EndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub end_time: Option<f64>,
    /// <p>The failure reason of a job.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>When the job was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
}

/// <p>The output data configuration.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AutoMLOutputDataConfig {
    /// <p>The AWS KMS encryption key ID.</p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>The Amazon S3 output path. Must be 128 characters or less.</p>
    #[serde(rename = "S3OutputPath")]
    pub s3_output_path: String,
}

/// <p>The Amazon S3 data source.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AutoMLS3DataSource {
    /// <p>The data type.</p>
    #[serde(rename = "S3DataType")]
    pub s3_data_type: String,
    /// <p>The URL to the Amazon S3 data source.</p>
    #[serde(rename = "S3Uri")]
    pub s3_uri: String,
}

/// <p>Security options.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AutoMLSecurityConfig {
    /// <p>Whether to use traffic encryption between the container layers.</p>
    #[serde(rename = "EnableInterContainerTrafficEncryption")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_inter_container_traffic_encryption: Option<bool>,
    /// <p>The key used to encrypt stored data.</p>
    #[serde(rename = "VolumeKmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume_kms_key_id: Option<String>,
    /// <p>VPC configuration.</p>
    #[serde(rename = "VpcConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpc_config: Option<VpcConfig>,
}

/// <p>Currently, the <code>AutoRollbackConfig</code> API is not supported.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AutoRollbackConfig {
    /// <p><p/></p>
    #[serde(rename = "Alarms")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alarms: Option<Vec<Alarm>>,
}

/// <p>Contains bias metrics for a model.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Bias {
    /// <p>The bias report for a model</p>
    #[serde(rename = "Report")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub report: Option<MetricsSource>,
}

/// <p>Currently, the <code>BlueGreenUpdatePolicy</code> API is not supported.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct BlueGreenUpdatePolicy {
    /// <p><p/></p>
    #[serde(rename = "MaximumExecutionTimeoutInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub maximum_execution_timeout_in_seconds: Option<i64>,
    /// <p><p/></p>
    #[serde(rename = "TerminationWaitInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub termination_wait_in_seconds: Option<i64>,
    /// <p><p/></p>
    #[serde(rename = "TrafficRoutingConfiguration")]
    pub traffic_routing_configuration: TrafficRoutingConfig,
}

/// <p>Details on the cache hit of a pipeline execution step.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CacheHitResult {
    /// <p>The Amazon Resource Name (ARN) of the pipeline execution.</p>
    #[serde(rename = "SourcePipelineExecutionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_pipeline_execution_arn: Option<String>,
}

/// <p>Currently, the <code>CapacitySize</code> API is not supported.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CapacitySize {
    /// <p>This API is not supported.</p>
    #[serde(rename = "Type")]
    pub type_: String,
    /// <p><p/></p>
    #[serde(rename = "Value")]
    pub value: i64,
}

/// <p><p/></p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CaptureContentTypeHeader {
    /// <p><p/></p>
    #[serde(rename = "CsvContentTypes")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub csv_content_types: Option<Vec<String>>,
    /// <p><p/></p>
    #[serde(rename = "JsonContentTypes")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub json_content_types: Option<Vec<String>>,
}

/// <p><p/></p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CaptureOption {
    /// <p><p/></p>
    #[serde(rename = "CaptureMode")]
    pub capture_mode: String,
}

/// <p>A list of categorical hyperparameters to tune.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CategoricalParameterRange {
    /// <p>The name of the categorical hyperparameter to tune.</p>
    #[serde(rename = "Name")]
    pub name: String,
    /// <p>A list of the categories for the hyperparameter.</p>
    #[serde(rename = "Values")]
    pub values: Vec<String>,
}

/// <p>Defines the possible values for a categorical hyperparameter.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CategoricalParameterRangeSpecification {
    /// <p>The allowed categories for the hyperparameter.</p>
    #[serde(rename = "Values")]
    pub values: Vec<String>,
}

/// <p>A channel is a named input source that training algorithms can consume. </p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Channel {
    /// <p>The name of the channel. </p>
    #[serde(rename = "ChannelName")]
    pub channel_name: String,
    /// <p>If training data is compressed, the compression type. The default value is <code>None</code>. <code>CompressionType</code> is used only in Pipe input mode. In File mode, leave this field unset or set it to None.</p>
    #[serde(rename = "CompressionType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub compression_type: Option<String>,
    /// <p>The MIME type of the data.</p>
    #[serde(rename = "ContentType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content_type: Option<String>,
    /// <p>The location of the channel data.</p>
    #[serde(rename = "DataSource")]
    pub data_source: DataSource,
    /// <p>(Optional) The input mode to use for the data channel in a training job. If you don't set a value for <code>InputMode</code>, Amazon SageMaker uses the value set for <code>TrainingInputMode</code>. Use this parameter to override the <code>TrainingInputMode</code> setting in a <a>AlgorithmSpecification</a> request when you have a channel that needs a different input mode from the training job's general setting. To download the data from Amazon Simple Storage Service (Amazon S3) to the provisioned ML storage volume, and mount the directory to a Docker volume, use <code>File</code> input mode. To stream data directly from Amazon S3 to the container, choose <code>Pipe</code> input mode.</p> <p>To use a model for incremental training, choose <code>File</code> input model.</p>
    #[serde(rename = "InputMode")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_mode: Option<String>,
    /// <p><p/> <p>Specify RecordIO as the value when input data is in raw format but the training algorithm requires the RecordIO format. In this case, Amazon SageMaker wraps each individual S3 object in a RecordIO record. If the input data is already in RecordIO format, you don&#39;t need to set this attribute. For more information, see <a href="https://mxnet.apache.org/api/architecture/note_data_loading#data-format">Create a Dataset Using RecordIO</a>. </p> <p>In File mode, leave this field unset or set it to None.</p></p>
    #[serde(rename = "RecordWrapperType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub record_wrapper_type: Option<String>,
    /// <p>A configuration for a shuffle option for input data in a channel. If you use <code>S3Prefix</code> for <code>S3DataType</code>, this shuffles the results of the S3 key prefix matches. If you use <code>ManifestFile</code>, the order of the S3 object references in the <code>ManifestFile</code> is shuffled. If you use <code>AugmentedManifestFile</code>, the order of the JSON lines in the <code>AugmentedManifestFile</code> is shuffled. The shuffling order is determined using the <code>Seed</code> value.</p> <p>For Pipe input mode, 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, it helps reduce bias and possible overfitting. In a multi-node training job when ShuffleConfig is combined with <code>S3DataDistributionType</code> of <code>ShardedByS3Key</code>, 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.</p>
    #[serde(rename = "ShuffleConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub shuffle_config: Option<ShuffleConfig>,
}

/// <p>Defines a named input source, called a channel, to be used by an algorithm.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ChannelSpecification {
    /// <p>A brief description of the channel.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>Indicates whether the channel is required by the algorithm.</p>
    #[serde(rename = "IsRequired")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_required: Option<bool>,
    /// <p>The name of the channel.</p>
    #[serde(rename = "Name")]
    pub name: String,
    /// <p>The allowed compression types, if data compression is used.</p>
    #[serde(rename = "SupportedCompressionTypes")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub supported_compression_types: Option<Vec<String>>,
    /// <p>The supported MIME types for the data.</p>
    #[serde(rename = "SupportedContentTypes")]
    pub supported_content_types: Vec<String>,
    /// <p>The allowed input mode, either FILE or PIPE.</p> <p>In FILE mode, Amazon SageMaker copies the data from the input source onto the local Amazon Elastic Block Store (Amazon EBS) volumes before starting your training algorithm. This is the most commonly used input mode.</p> <p>In PIPE mode, Amazon SageMaker streams input data from the source directly to your algorithm without using the EBS volume.</p>
    #[serde(rename = "SupportedInputModes")]
    pub supported_input_modes: Vec<String>,
}

/// <p>Contains information about the output location for managed spot training checkpoint data. </p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CheckpointConfig {
    /// <p>(Optional) The local directory where checkpoints are written. The default directory is <code>/opt/ml/checkpoints/</code>. </p>
    #[serde(rename = "LocalPath")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub local_path: Option<String>,
    /// <p>Identifies the S3 path where you want Amazon SageMaker to store checkpoints. For example, <code>s3://bucket-name/key-name-prefix</code>.</p>
    #[serde(rename = "S3Uri")]
    pub s3_uri: String,
}

/// <p>Specifies summary information about a Git repository.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CodeRepositorySummary {
    /// <p>The Amazon Resource Name (ARN) of the Git repository.</p>
    #[serde(rename = "CodeRepositoryArn")]
    pub code_repository_arn: String,
    /// <p>The name of the Git repository.</p>
    #[serde(rename = "CodeRepositoryName")]
    pub code_repository_name: String,
    /// <p>The date and time that the Git repository was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>Configuration details for the Git repository, including the URL where it is located and the ARN of the AWS Secrets Manager secret that contains the credentials used to access the repository.</p>
    #[serde(rename = "GitConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub git_config: Option<GitConfig>,
    /// <p>The date and time that the Git repository was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
}

/// <p>Use this parameter to configure your Amazon Cognito workforce. A single Cognito workforce is created using and corresponds to a single <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html"> Amazon Cognito user pool</a>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CognitoConfig {
    /// <p>The client ID for your Amazon Cognito user pool.</p>
    #[serde(rename = "ClientId")]
    pub client_id: String,
    /// <p>A <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html"> user pool</a> is a user directory in Amazon Cognito. With a user pool, your users can sign in to your web or mobile app through Amazon Cognito. Your users can also sign in through social identity providers like Google, Facebook, Amazon, or Apple, and through SAML identity providers.</p>
    #[serde(rename = "UserPool")]
    pub user_pool: String,
}

/// <p>Identifies a Amazon Cognito user group. A user group can be used in on or more work teams.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CognitoMemberDefinition {
    /// <p>An identifier for an application client. You must create the app client ID using Amazon Cognito.</p>
    #[serde(rename = "ClientId")]
    pub client_id: String,
    /// <p>An identifier for a user group.</p>
    #[serde(rename = "UserGroup")]
    pub user_group: String,
    /// <p>An identifier for a user pool. The user pool must be in the same region as the service that you are calling.</p>
    #[serde(rename = "UserPool")]
    pub user_pool: String,
}

/// <p>Configuration information for the Debugger output tensor collections.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CollectionConfiguration {
    /// <p>The name of the tensor collection. The name must be unique relative to other rule configuration names.</p>
    #[serde(rename = "CollectionName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub collection_name: Option<String>,
    /// <p>Parameter values for the tensor collection. The allowed parameters are <code>"name"</code>, <code>"include_regex"</code>, <code>"reduction_config"</code>, <code>"save_config"</code>, <code>"tensor_names"</code>, and <code>"save_histogram"</code>.</p>
    #[serde(rename = "CollectionParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub collection_parameters: Option<::std::collections::HashMap<String, String>>,
}

/// <p>A summary of a model compilation job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CompilationJobSummary {
    /// <p>The time when the model compilation job completed.</p>
    #[serde(rename = "CompilationEndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub compilation_end_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the model compilation job.</p>
    #[serde(rename = "CompilationJobArn")]
    pub compilation_job_arn: String,
    /// <p>The name of the model compilation job that you want a summary for.</p>
    #[serde(rename = "CompilationJobName")]
    pub compilation_job_name: String,
    /// <p>The status of the model compilation job.</p>
    #[serde(rename = "CompilationJobStatus")]
    pub compilation_job_status: String,
    /// <p>The time when the model compilation job started.</p>
    #[serde(rename = "CompilationStartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub compilation_start_time: Option<f64>,
    /// <p>The type of device that the model will run on after the compilation job has completed.</p>
    #[serde(rename = "CompilationTargetDevice")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub compilation_target_device: Option<String>,
    /// <p>The type of accelerator that the model will run on after the compilation job has completed.</p>
    #[serde(rename = "CompilationTargetPlatformAccelerator")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub compilation_target_platform_accelerator: Option<String>,
    /// <p>The type of architecture that the model will run on after the compilation job has completed.</p>
    #[serde(rename = "CompilationTargetPlatformArch")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub compilation_target_platform_arch: Option<String>,
    /// <p>The type of OS that the model will run on after the compilation job has completed.</p>
    #[serde(rename = "CompilationTargetPlatformOs")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub compilation_target_platform_os: Option<String>,
    /// <p>The time when the model compilation job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The time when the model compilation job was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
}

/// <p>Metadata for a Condition step.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConditionStepMetadata {
    /// <p>The outcome of the Condition step evaluation.</p>
    #[serde(rename = "Outcome")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub outcome: Option<String>,
}

/// <p>Describes the container, as part of model definition.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ContainerDefinition {
    /// <p>This parameter is ignored for models that contain only a <code>PrimaryContainer</code>.</p> <p>When a <code>ContainerDefinition</code> is part of an inference pipeline, the value of the parameter uniquely identifies the container for the purposes of logging and metrics. For information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipeline-logs-metrics.html">Use Logs and Metrics to Monitor an Inference Pipeline</a>. If you don't specify a value for this parameter for a <code>ContainerDefinition</code> that is part of an inference pipeline, a unique name is automatically assigned based on the position of the <code>ContainerDefinition</code> in the pipeline. If you specify a value for the <code>ContainerHostName</code> for any <code>ContainerDefinition</code> that is part of an inference pipeline, you must specify a value for the <code>ContainerHostName</code> parameter of every <code>ContainerDefinition</code> in that pipeline.</p>
    #[serde(rename = "ContainerHostname")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_hostname: Option<String>,
    /// <p>The environment variables to set in the Docker container. Each key and value in the <code>Environment</code> string to string map can have length of up to 1024. We support up to 16 entries in the map. </p>
    #[serde(rename = "Environment")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub environment: Option<::std::collections::HashMap<String, String>>,
    /// <p>The path where inference code is stored. This can be either in Amazon EC2 Container Registry or in a Docker registry that is accessible from the same VPC that you configure for your endpoint. If you are using your own custom algorithm instead of an algorithm provided by Amazon SageMaker, the inference code must meet Amazon SageMaker requirements. Amazon SageMaker supports both <code>registry/repository[:tag]</code> and <code>registry/repository[@digest]</code> image path formats. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms.html">Using Your Own Algorithms with Amazon SageMaker</a> </p>
    #[serde(rename = "Image")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    /// <p>Specifies whether the model container is in Amazon ECR or a private Docker registry accessible from your Amazon Virtual Private Cloud (VPC). For information about storing containers in a private Docker registry, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-containers-inference-private.html">Use a Private Docker Registry for Real-Time Inference Containers</a> </p>
    #[serde(rename = "ImageConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_config: Option<ImageConfig>,
    /// <p>Whether the container hosts a single model or multiple models.</p>
    #[serde(rename = "Mode")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mode: Option<String>,
    /// <p><p>The S3 path where the model artifacts, which result from model training, are stored. This path must point to a single gzip compressed tar archive (.tar.gz suffix). The S3 path is required for Amazon SageMaker built-in algorithms, but not if you use your own algorithms. For more information on built-in algorithms, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html">Common Parameters</a>. </p> <note> <p>The model artifacts must be in an S3 bucket that is in the same region as the model or endpoint you are creating.</p> </note> <p>If you provide a value for this parameter, Amazon SageMaker uses AWS Security Token Service to download model artifacts from the S3 path you provide. AWS STS is activated in your IAM user account by default. If you previously deactivated AWS STS for a region, you need to reactivate AWS STS for that region. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html">Activating and Deactivating AWS STS in an AWS Region</a> in the <i>AWS Identity and Access Management User Guide</i>.</p> <important> <p>If you use a built-in algorithm to create a model, Amazon SageMaker requires that you provide a S3 path to the model artifacts in <code>ModelDataUrl</code>.</p> </important></p>
    #[serde(rename = "ModelDataUrl")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_data_url: Option<String>,
    /// <p>The name or Amazon Resource Name (ARN) of the model package to use to create the model.</p>
    #[serde(rename = "ModelPackageName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_name: Option<String>,
}

/// <p>A structure describing the source of a context.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ContextSource {
    /// <p>The ID of the source.</p>
    #[serde(rename = "SourceId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_id: Option<String>,
    /// <p>The type of the source.</p>
    #[serde(rename = "SourceType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_type: Option<String>,
    /// <p>The URI of the source.</p>
    #[serde(rename = "SourceUri")]
    pub source_uri: String,
}

/// <p>Lists a summary of the properties of a context. A context provides a logical grouping of other entities.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ContextSummary {
    /// <p>The Amazon Resource Name (ARN) of the context.</p>
    #[serde(rename = "ContextArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context_arn: Option<String>,
    /// <p>The name of the context.</p>
    #[serde(rename = "ContextName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context_name: Option<String>,
    /// <p>The type of the context.</p>
    #[serde(rename = "ContextType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context_type: Option<String>,
    /// <p>When the context was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>When the context was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The source of the context.</p>
    #[serde(rename = "Source")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<ContextSource>,
}

/// <p>A list of continuous hyperparameters to tune.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ContinuousParameterRange {
    /// <p>The maximum value for the hyperparameter. The tuning job uses floating-point values between <code>MinValue</code> value and this value for tuning.</p>
    #[serde(rename = "MaxValue")]
    pub max_value: String,
    /// <p>The minimum value for the hyperparameter. The tuning job uses floating-point values between this value and <code>MaxValue</code>for tuning.</p>
    #[serde(rename = "MinValue")]
    pub min_value: String,
    /// <p>The name of the continuous hyperparameter to tune.</p>
    #[serde(rename = "Name")]
    pub name: String,
    /// <p><p>The scale that hyperparameter tuning uses to search the hyperparameter range. For information about choosing a hyperparameter scale, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-define-ranges.html#scaling-type">Hyperparameter Scaling</a>. One of the following values:</p> <dl> <dt>Auto</dt> <dd> <p>Amazon SageMaker hyperparameter tuning chooses the best scale for the hyperparameter.</p> </dd> <dt>Linear</dt> <dd> <p>Hyperparameter tuning searches the values in the hyperparameter range by using a linear scale.</p> </dd> <dt>Logarithmic</dt> <dd> <p>Hyperparameter tuning searches the values in the hyperparameter range by using a logarithmic scale.</p> <p>Logarithmic scaling works only for ranges that have only values greater than 0.</p> </dd> <dt>ReverseLogarithmic</dt> <dd> <p>Hyperparameter tuning searches the values in the hyperparameter range by using a reverse logarithmic scale.</p> <p>Reverse logarithmic scaling works only for ranges that are entirely within the range 0&lt;=x&lt;1.0.</p> </dd> </dl></p>
    #[serde(rename = "ScalingType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub scaling_type: Option<String>,
}

/// <p>Defines the possible values for a continuous hyperparameter.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ContinuousParameterRangeSpecification {
    /// <p>The maximum floating-point value allowed.</p>
    #[serde(rename = "MaxValue")]
    pub max_value: String,
    /// <p>The minimum floating-point value allowed.</p>
    #[serde(rename = "MinValue")]
    pub min_value: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateActionRequest {
    /// <p>The name of the action. Must be unique to your account in an AWS Region.</p>
    #[serde(rename = "ActionName")]
    pub action_name: String,
    /// <p>The action type.</p>
    #[serde(rename = "ActionType")]
    pub action_type: String,
    /// <p>The description of the action.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(rename = "MetadataProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_properties: Option<MetadataProperties>,
    /// <p>A list of properties to add to the action.</p>
    #[serde(rename = "Properties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub properties: Option<::std::collections::HashMap<String, String>>,
    /// <p>The source type, ID, and URI.</p>
    #[serde(rename = "Source")]
    pub source: ActionSource,
    /// <p>The status of the action.</p>
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    /// <p>A list of tags to apply to the action.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateActionResponse {
    /// <p>The Amazon Resource Name (ARN) of the action.</p>
    #[serde(rename = "ActionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub action_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateAlgorithmInput {
    /// <p>A description of the algorithm.</p>
    #[serde(rename = "AlgorithmDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub algorithm_description: Option<String>,
    /// <p>The name of the algorithm.</p>
    #[serde(rename = "AlgorithmName")]
    pub algorithm_name: String,
    /// <p>Whether to certify the algorithm so that it can be listed in AWS Marketplace.</p>
    #[serde(rename = "CertifyForMarketplace")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub certify_for_marketplace: Option<bool>,
    /// <p><p>Specifies details about inference jobs that the algorithm runs, including the following:</p> <ul> <li> <p>The Amazon ECR paths of containers that contain the inference code and model artifacts.</p> </li> <li> <p>The instance types that the algorithm supports for transform jobs and real-time endpoints used for inference.</p> </li> <li> <p>The input and output content formats that the algorithm supports for inference.</p> </li> </ul></p>
    #[serde(rename = "InferenceSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inference_specification: Option<InferenceSpecification>,
    /// <p>An array of key-value pairs. You can use tags to categorize your AWS resources in different ways, for example, by purpose, owner, or environment. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS Resources</a>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p><p>Specifies details about training jobs run by this algorithm, including the following:</p> <ul> <li> <p>The Amazon ECR path of the container and the version digest of the algorithm.</p> </li> <li> <p>The hyperparameters that the algorithm supports.</p> </li> <li> <p>The instance types that the algorithm supports for training.</p> </li> <li> <p>Whether the algorithm supports distributed training.</p> </li> <li> <p>The metrics that the algorithm emits to Amazon CloudWatch.</p> </li> <li> <p>Which metrics that the algorithm emits can be used as the objective metric for hyperparameter tuning jobs.</p> </li> <li> <p>The input channels that the algorithm supports for training data. For example, an algorithm might support <code>train</code>, <code>validation</code>, and <code>test</code> channels.</p> </li> </ul></p>
    #[serde(rename = "TrainingSpecification")]
    pub training_specification: TrainingSpecification,
    /// <p>Specifies configurations for one or more training jobs and that Amazon SageMaker runs to test the algorithm's training code and, optionally, one or more batch transform jobs that Amazon SageMaker runs to test the algorithm's inference code.</p>
    #[serde(rename = "ValidationSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub validation_specification: Option<AlgorithmValidationSpecification>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateAlgorithmOutput {
    /// <p>The Amazon Resource Name (ARN) of the new algorithm.</p>
    #[serde(rename = "AlgorithmArn")]
    pub algorithm_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateAppImageConfigRequest {
    /// <p>The name of the AppImageConfig. Must be unique to your account.</p>
    #[serde(rename = "AppImageConfigName")]
    pub app_image_config_name: String,
    /// <p>The KernelGatewayImageConfig.</p>
    #[serde(rename = "KernelGatewayImageConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kernel_gateway_image_config: Option<KernelGatewayImageConfig>,
    /// <p>A list of tags to apply to the AppImageConfig.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateAppImageConfigResponse {
    /// <p>The Amazon Resource Name (ARN) of the AppImageConfig.</p>
    #[serde(rename = "AppImageConfigArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_image_config_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateAppRequest {
    /// <p>The name of the app.</p>
    #[serde(rename = "AppName")]
    pub app_name: String,
    /// <p>The type of app.</p>
    #[serde(rename = "AppType")]
    pub app_type: String,
    /// <p>The domain ID.</p>
    #[serde(rename = "DomainId")]
    pub domain_id: String,
    /// <p>The instance type and the Amazon Resource Name (ARN) of the SageMaker image created on the instance.</p>
    #[serde(rename = "ResourceSpec")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resource_spec: Option<ResourceSpec>,
    /// <p>Each tag consists of a key and an optional value. Tag keys must be unique per resource.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>The user profile name.</p>
    #[serde(rename = "UserProfileName")]
    pub user_profile_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateAppResponse {
    /// <p>The Amazon Resource Name (ARN) of the app.</p>
    #[serde(rename = "AppArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateArtifactRequest {
    /// <p>The name of the artifact. Must be unique to your account in an AWS Region.</p>
    #[serde(rename = "ArtifactName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artifact_name: Option<String>,
    /// <p>The artifact type.</p>
    #[serde(rename = "ArtifactType")]
    pub artifact_type: String,
    #[serde(rename = "MetadataProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_properties: Option<MetadataProperties>,
    /// <p>A list of properties to add to the artifact.</p>
    #[serde(rename = "Properties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub properties: Option<::std::collections::HashMap<String, String>>,
    /// <p>The ID, ID type, and URI of the source.</p>
    #[serde(rename = "Source")]
    pub source: ArtifactSource,
    /// <p>A list of tags to apply to the artifact.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateArtifactResponse {
    /// <p>The Amazon Resource Name (ARN) of the artifact.</p>
    #[serde(rename = "ArtifactArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artifact_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateAutoMLJobRequest {
    /// <p>Contains CompletionCriteria and SecurityConfig.</p>
    #[serde(rename = "AutoMLJobConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_ml_job_config: Option<AutoMLJobConfig>,
    /// <p>Identifies an Autopilot job. Must be unique to your account and is case-insensitive.</p>
    #[serde(rename = "AutoMLJobName")]
    pub auto_ml_job_name: String,
    /// <p>Defines the objective of a an AutoML job. You provide a <a>AutoMLJobObjective$MetricName</a> and Autopilot infers whether to minimize or maximize it. If a metric is not specified, the most commonly used ObjectiveMetric for problem type is automaically selected.</p>
    #[serde(rename = "AutoMLJobObjective")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_ml_job_objective: Option<AutoMLJobObjective>,
    /// <p>Generates possible candidates without training a model. A candidate is a combination of data preprocessors, algorithms, and algorithm parameter settings.</p>
    #[serde(rename = "GenerateCandidateDefinitionsOnly")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub generate_candidate_definitions_only: Option<bool>,
    /// <p>Similar to InputDataConfig supported by Tuning. Format(s) supported: CSV. Minimum of 500 rows.</p>
    #[serde(rename = "InputDataConfig")]
    pub input_data_config: Vec<AutoMLChannel>,
    /// <p>Similar to OutputDataConfig supported by Tuning. Format(s) supported: CSV.</p>
    #[serde(rename = "OutputDataConfig")]
    pub output_data_config: AutoMLOutputDataConfig,
    /// <p>Defines the kind of preprocessing and algorithms intended for the candidates. Options include: BinaryClassification, MulticlassClassification, and Regression.</p>
    #[serde(rename = "ProblemType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub problem_type: Option<String>,
    /// <p>The ARN of the role that is used to access the data.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    /// <p>Each tag consists of a key and an optional value. Tag keys must be unique per resource.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateAutoMLJobResponse {
    /// <p>When a job is created, it is assigned a unique ARN.</p>
    #[serde(rename = "AutoMLJobArn")]
    pub auto_ml_job_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCodeRepositoryInput {
    /// <p>The name of the Git repository. The name must have 1 to 63 characters. Valid characters are a-z, A-Z, 0-9, and - (hyphen).</p>
    #[serde(rename = "CodeRepositoryName")]
    pub code_repository_name: String,
    /// <p>Specifies details about the repository, including the URL where the repository is located, the default branch, and credentials to use to access the repository.</p>
    #[serde(rename = "GitConfig")]
    pub git_config: GitConfig,
    /// <p>An array of key-value pairs. You can use tags to categorize your AWS resources in different ways, for example, by purpose, owner, or environment. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS Resources</a>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateCodeRepositoryOutput {
    /// <p>The Amazon Resource Name (ARN) of the new repository.</p>
    #[serde(rename = "CodeRepositoryArn")]
    pub code_repository_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCompilationJobRequest {
    /// <p>A name for the model compilation job. The name must be unique within the AWS Region and within your AWS account. </p>
    #[serde(rename = "CompilationJobName")]
    pub compilation_job_name: String,
    /// <p>Provides 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.</p>
    #[serde(rename = "InputConfig")]
    pub input_config: InputConfig,
    /// <p>Provides information about the output location for the compiled model and the target device the model runs on.</p>
    #[serde(rename = "OutputConfig")]
    pub output_config: OutputConfig,
    /// <p>The Amazon Resource Name (ARN) of an IAM role that enables Amazon SageMaker to perform tasks on your behalf. </p> <p>During model compilation, Amazon SageMaker needs your permission to:</p> <ul> <li> <p>Read input data from an S3 bucket</p> </li> <li> <p>Write model artifacts to an S3 bucket</p> </li> <li> <p>Write logs to Amazon CloudWatch Logs</p> </li> <li> <p>Publish metrics to Amazon CloudWatch</p> </li> </ul> <p>You grant permissions for all of these tasks to an IAM role. To pass this role to Amazon SageMaker, the caller of this API must have the <code>iam:PassRole</code> permission. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html">Amazon SageMaker Roles.</a> </p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    /// <p>Specifies a limit to how long a model compilation job can run. When the job reaches the time limit, Amazon SageMaker ends the compilation job. Use this API to cap model training costs.</p>
    #[serde(rename = "StoppingCondition")]
    pub stopping_condition: StoppingCondition,
    /// <p>An array of key-value pairs. You can use tags to categorize your AWS resources in different ways, for example, by purpose, owner, or environment. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS Resources</a>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateCompilationJobResponse {
    /// <p><p>If the action is successful, the service sends back an HTTP 200 response. Amazon SageMaker returns the following data in JSON format:</p> <ul> <li> <p> <code>CompilationJobArn</code>: The Amazon Resource Name (ARN) of the compiled job.</p> </li> </ul></p>
    #[serde(rename = "CompilationJobArn")]
    pub compilation_job_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateContextRequest {
    /// <p>The name of the context. Must be unique to your account in an AWS Region.</p>
    #[serde(rename = "ContextName")]
    pub context_name: String,
    /// <p>The context type.</p>
    #[serde(rename = "ContextType")]
    pub context_type: String,
    /// <p>The description of the context.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>A list of properties to add to the context.</p>
    #[serde(rename = "Properties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub properties: Option<::std::collections::HashMap<String, String>>,
    /// <p>The source type, ID, and URI.</p>
    #[serde(rename = "Source")]
    pub source: ContextSource,
    /// <p>A list of tags to apply to the context.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateContextResponse {
    /// <p>The Amazon Resource Name (ARN) of the context.</p>
    #[serde(rename = "ContextArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDataQualityJobDefinitionRequest {
    /// <p>Specifies the container that runs the monitoring job.</p>
    #[serde(rename = "DataQualityAppSpecification")]
    pub data_quality_app_specification: DataQualityAppSpecification,
    /// <p>Configures the constraints and baselines for the monitoring job.</p>
    #[serde(rename = "DataQualityBaselineConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data_quality_baseline_config: Option<DataQualityBaselineConfig>,
    /// <p>A list of inputs for the monitoring job. Currently endpoints are supported as monitoring inputs.</p>
    #[serde(rename = "DataQualityJobInput")]
    pub data_quality_job_input: DataQualityJobInput,
    #[serde(rename = "DataQualityJobOutputConfig")]
    pub data_quality_job_output_config: MonitoringOutputConfig,
    /// <p>The name for the monitoring job definition.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
    #[serde(rename = "JobResources")]
    pub job_resources: MonitoringResources,
    /// <p>Specifies networking configuration for the monitoring job.</p>
    #[serde(rename = "NetworkConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub network_config: Option<MonitoringNetworkConfig>,
    /// <p>The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume to perform tasks on your behalf.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    #[serde(rename = "StoppingCondition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopping_condition: Option<MonitoringStoppingCondition>,
    /// <p>(Optional) An array of key-value pairs. For more information, see <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-whatURL">Using Cost Allocation Tags</a> in the <i>AWS Billing and Cost Management User Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDataQualityJobDefinitionResponse {
    /// <p>The Amazon Resource Name (ARN) of the job definition.</p>
    #[serde(rename = "JobDefinitionArn")]
    pub job_definition_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDeviceFleetRequest {
    /// <p>A description of the fleet.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The name of the fleet that the device belongs to.</p>
    #[serde(rename = "DeviceFleetName")]
    pub device_fleet_name: String,
    /// <p>The output configuration for storing sample data collected by the fleet.</p>
    #[serde(rename = "OutputConfig")]
    pub output_config: EdgeOutputConfig,
    /// <p>The Amazon Resource Name (ARN) that has access to AWS Internet of Things (IoT).</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
    /// <p>Creates tags for the specified fleet.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDomainRequest {
    /// <p><p>Specifies the VPC used for non-EFS traffic. The default value is <code>PublicInternetOnly</code>.</p> <ul> <li> <p> <code>PublicInternetOnly</code> - Non-EFS traffic is through a VPC managed by Amazon SageMaker, which allows direct internet access</p> </li> <li> <p> <code>VpcOnly</code> - All Studio traffic is through the specified VPC and subnets</p> </li> </ul></p>
    #[serde(rename = "AppNetworkAccessType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_network_access_type: Option<String>,
    /// <p>The mode of authentication that members use to access the domain.</p>
    #[serde(rename = "AuthMode")]
    pub auth_mode: String,
    /// <p>The default user settings.</p>
    #[serde(rename = "DefaultUserSettings")]
    pub default_user_settings: UserSettings,
    /// <p>A name for the domain.</p>
    #[serde(rename = "DomainName")]
    pub domain_name: String,
    /// <p>SageMaker uses AWS KMS to encrypt the EFS volume attached to the domain with an AWS managed customer master key (CMK) by default. For more control, specify a customer managed CMK.</p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>The VPC subnets that Studio uses for communication.</p>
    #[serde(rename = "SubnetIds")]
    pub subnet_ids: Vec<String>,
    /// <p>Tags to associated with the Domain. Each tag consists of a key and an optional value. Tag keys must be unique per resource. Tags are searchable using the <a>Search</a> API.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>The ID of the Amazon Virtual Private Cloud (VPC) that Studio uses for communication.</p>
    #[serde(rename = "VpcId")]
    pub vpc_id: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDomainResponse {
    /// <p>The Amazon Resource Name (ARN) of the created domain.</p>
    #[serde(rename = "DomainArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_arn: Option<String>,
    /// <p>The URL to the created domain.</p>
    #[serde(rename = "Url")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateEdgePackagingJobRequest {
    /// <p>The name of the SageMaker Neo compilation job that will be used to locate model artifacts for packaging.</p>
    #[serde(rename = "CompilationJobName")]
    pub compilation_job_name: String,
    /// <p>The name of the edge packaging job.</p>
    #[serde(rename = "EdgePackagingJobName")]
    pub edge_packaging_job_name: String,
    /// <p>The name of the model.</p>
    #[serde(rename = "ModelName")]
    pub model_name: String,
    /// <p>The version of the model.</p>
    #[serde(rename = "ModelVersion")]
    pub model_version: String,
    /// <p>Provides information about the output location for the packaged model.</p>
    #[serde(rename = "OutputConfig")]
    pub output_config: EdgeOutputConfig,
    /// <p>The CMK to use when encrypting the EBS volume the edge packaging job runs on.</p>
    #[serde(rename = "ResourceKey")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resource_key: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of an IAM role that enables Amazon SageMaker to download and upload the model, and to contact SageMaker Neo.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    /// <p>Creates tags for the packaging job.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateEndpointConfigInput {
    #[serde(rename = "DataCaptureConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data_capture_config: Option<DataCaptureConfig>,
    /// <p>The name of the endpoint configuration. You specify this name in a <a>CreateEndpoint</a> request. </p>
    #[serde(rename = "EndpointConfigName")]
    pub endpoint_config_name: String,
    /// <p><p>The Amazon Resource Name (ARN) of a AWS Key Management Service key that Amazon SageMaker uses to encrypt data on the storage volume attached to the ML compute instance that hosts the endpoint.</p> <p>The KmsKeyId can be any of the following formats: </p> <ul> <li> <p>Key ID: <code>1234abcd-12ab-34cd-56ef-1234567890ab</code> </p> </li> <li> <p>Key ARN: <code>arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab</code> </p> </li> <li> <p>Alias name: <code>alias/ExampleAlias</code> </p> </li> <li> <p>Alias name ARN: <code>arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias</code> </p> </li> </ul> <p>The KMS key policy must grant permission to the IAM role that you specify in your <code>CreateEndpoint</code>, <code>UpdateEndpoint</code> requests. For more information, refer to the AWS Key Management Service section<a href="https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html"> Using Key Policies in AWS KMS </a> </p> <note> <p>Certain Nitro-based instances include local storage, dependent on the instance type. Local storage volumes are encrypted using a hardware module on the instance. You can&#39;t request a <code>KmsKeyId</code> when using an instance type with local storage. If any of the models that you specify in the <code>ProductionVariants</code> parameter use nitro-based instances with local storage, do not specify a value for the <code>KmsKeyId</code> parameter. If you specify a value for <code>KmsKeyId</code> when using any nitro-based instances with local storage, the call to <code>CreateEndpointConfig</code> fails.</p> <p>For a list of instance types that support local instance storage, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html#instance-store-volumes">Instance Store Volumes</a>.</p> <p>For more information about local instance storage encryption, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ssd-instance-store.html">SSD Instance Store Volumes</a>.</p> </note></p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>An list of <code>ProductionVariant</code> objects, one for each model that you want to host at this endpoint.</p>
    #[serde(rename = "ProductionVariants")]
    pub production_variants: Vec<ProductionVariant>,
    /// <p>An array of key-value pairs. You can use tags to categorize your AWS resources in different ways, for example, by purpose, owner, or environment. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS Resources</a>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateEndpointConfigOutput {
    /// <p>The Amazon Resource Name (ARN) of the endpoint configuration. </p>
    #[serde(rename = "EndpointConfigArn")]
    pub endpoint_config_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateEndpointInput {
    /// <p>The name of an endpoint configuration. For more information, see <a>CreateEndpointConfig</a>. </p>
    #[serde(rename = "EndpointConfigName")]
    pub endpoint_config_name: String,
    /// <p>The name of the endpoint.The name must be unique within an AWS Region in your AWS account. The name is case-insensitive in <code>CreateEndpoint</code>, but the case is preserved and must be matched in .</p>
    #[serde(rename = "EndpointName")]
    pub endpoint_name: String,
    /// <p>An array of key-value pairs. You can use tags to categorize your AWS resources in different ways, for example, by purpose, owner, or environment. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS Resources</a>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateEndpointOutput {
    /// <p>The Amazon Resource Name (ARN) of the endpoint.</p>
    #[serde(rename = "EndpointArn")]
    pub endpoint_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateExperimentRequest {
    /// <p>The description of the experiment.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The name of the experiment as displayed. The name doesn't need to be unique. If you don't specify <code>DisplayName</code>, the value in <code>ExperimentName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>The name of the experiment. The name must be unique in your AWS account and is not case-sensitive.</p>
    #[serde(rename = "ExperimentName")]
    pub experiment_name: String,
    /// <p>A list of tags to associate with the experiment. You can use <a>Search</a> API to search on the tags.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateExperimentResponse {
    /// <p>The Amazon Resource Name (ARN) of the experiment.</p>
    #[serde(rename = "ExperimentArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFeatureGroupRequest {
    /// <p>A free-form description of a <code>FeatureGroup</code>.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p><p>The name of the feature that stores the <code>EventTime</code> of a <code>Record</code> in a <code>FeatureGroup</code>.</p> <p>An <code>EventTime</code> is a point in time when a new event occurs that corresponds to the creation or update of a <code>Record</code> in a <code>FeatureGroup</code>. All <code>Records</code> in the <code>FeatureGroup</code> must have a corresponding <code>EventTime</code>.</p> <p>An <code>EventTime</code> can be a <code>String</code> or <code>Fractional</code>. </p> <ul> <li> <p> <code>Fractional</code>: <code>EventTime</code> feature values must be a Unix timestamp in seconds.</p> </li> <li> <p> <code>String</code>: <code>EventTime</code> feature values must be an ISO-8601 string in the format. The following formats are supported <code>yyyy-MM-dd&#39;T&#39;HH:mm:ssZ</code> and <code>yyyy-MM-dd&#39;T&#39;HH:mm:ss.SSSZ</code> where <code>yyyy</code>, <code>MM</code>, and <code>dd</code> represent the year, month, and day respectively and <code>HH</code>, <code>mm</code>, <code>ss</code>, and if applicable, <code>SSS</code> represent the hour, month, second and milliseconds respsectively. <code>&#39;T&#39;</code> and <code>Z</code> are constants.</p> </li> </ul></p>
    #[serde(rename = "EventTimeFeatureName")]
    pub event_time_feature_name: String,
    /// <p>A list of <code>Feature</code> names and types. <code>Name</code> and <code>Type</code> is compulsory per <code>Feature</code>. </p> <p>Valid feature <code>FeatureType</code>s are <code>Integral</code>, <code>Fractional</code> and <code>String</code>.</p> <p> <code>FeatureName</code>s cannot be any of the following: <code>is_deleted</code>, <code>write_time</code>, <code>api_invocation_time</code> </p> <p>You can create up to 2,500 <code>FeatureDefinition</code>s per <code>FeatureGroup</code>.</p>
    #[serde(rename = "FeatureDefinitions")]
    pub feature_definitions: Vec<FeatureDefinition>,
    /// <p><p>The name of the <code>FeatureGroup</code>. The name must be unique within an AWS Region in an AWS account. The name:</p> <ul> <li> <p>Must start and end with an alphanumeric character.</p> </li> <li> <p>Can only contain alphanumeric character and hyphens. Spaces are not allowed. </p> </li> </ul></p>
    #[serde(rename = "FeatureGroupName")]
    pub feature_group_name: String,
    /// <p>Use this to configure an <code>OfflineFeatureStore</code>. This parameter allows you to specify:</p> <ul> <li> <p>The Amazon Simple Storage Service (Amazon S3) location of an <code>OfflineStore</code>.</p> </li> <li> <p>A configuration for an AWS Glue or AWS Hive data cataolgue. </p> </li> <li> <p>An KMS encryption key to encrypt the Amazon S3 location used for <code>OfflineStore</code>.</p> </li> </ul> <p>To learn more about this parameter, see <a>OfflineStoreConfig</a>.</p>
    #[serde(rename = "OfflineStoreConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offline_store_config: Option<OfflineStoreConfig>,
    /// <p>You can turn the <code>OnlineStore</code> on or off by specifying <code>True</code> for the <code>EnableOnlineStore</code> flag in <code>OnlineStoreConfig</code>; the default value is <code>False</code>.</p> <p>You can also include an AWS KMS key ID (<code>KMSKeyId</code>) for at-rest encryption of the <code>OnlineStore</code>.</p>
    #[serde(rename = "OnlineStoreConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub online_store_config: Option<OnlineStoreConfig>,
    /// <p><p>The name of the <code>Feature</code> whose value uniquely identifies a <code>Record</code> defined in the <code>FeatureStore</code>. Only the latest record per identifier value will be stored in the <code>OnlineStore</code>. <code>RecordIdentifierFeatureName</code> must be one of feature definitions&#39; names.</p> <p>You use the <code>RecordIdentifierFeatureName</code> to access data in a <code>FeatureStore</code>.</p> <p>This name:</p> <ul> <li> <p>Must start and end with an alphanumeric character.</p> </li> <li> <p>Can only contains alphanumeric characters, hyphens, underscores. Spaces are not allowed. </p> </li> </ul></p>
    #[serde(rename = "RecordIdentifierFeatureName")]
    pub record_identifier_feature_name: String,
    /// <p>The Amazon Resource Name (ARN) of the IAM execution role used to persist data into the <code>OfflineStore</code> if an <code>OfflineStoreConfig</code> is provided.</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
    /// <p>Tags used to identify <code>Features</code> in each <code>FeatureGroup</code>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateFeatureGroupResponse {
    /// <p>The Amazon Resource Name (ARN) of the <code>FeatureGroup</code>. This is a unique identifier for the feature group. </p>
    #[serde(rename = "FeatureGroupArn")]
    pub feature_group_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFlowDefinitionRequest {
    /// <p>The name of your flow definition.</p>
    #[serde(rename = "FlowDefinitionName")]
    pub flow_definition_name: String,
    /// <p>An object containing information about the events that trigger a human workflow.</p>
    #[serde(rename = "HumanLoopActivationConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub human_loop_activation_config: Option<HumanLoopActivationConfig>,
    /// <p>An object containing information about the tasks the human reviewers will perform.</p>
    #[serde(rename = "HumanLoopConfig")]
    pub human_loop_config: HumanLoopConfig,
    /// <p>Container for configuring the source of human task requests. Use to specify if Amazon Rekognition or Amazon Textract is used as an integration source.</p>
    #[serde(rename = "HumanLoopRequestSource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub human_loop_request_source: Option<HumanLoopRequestSource>,
    /// <p>An object containing information about where the human review results will be uploaded.</p>
    #[serde(rename = "OutputConfig")]
    pub output_config: FlowDefinitionOutputConfig,
    /// <p>The Amazon Resource Name (ARN) of the role needed to call other services on your behalf. For example, <code>arn:aws:iam::1234567890:role/service-role/AmazonSageMaker-ExecutionRole-20180111T151298</code>.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    /// <p>An array of key-value pairs that contain metadata to help you categorize and organize a flow definition. Each tag consists of a key and a value, both of which you define.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateFlowDefinitionResponse {
    /// <p>The Amazon Resource Name (ARN) of the flow definition you create.</p>
    #[serde(rename = "FlowDefinitionArn")]
    pub flow_definition_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateHumanTaskUiRequest {
    /// <p>The name of the user interface you are creating.</p>
    #[serde(rename = "HumanTaskUiName")]
    pub human_task_ui_name: String,
    /// <p>An array of key-value pairs that contain metadata to help you categorize and organize a human review workflow user interface. Each tag consists of a key and a value, both of which you define.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    #[serde(rename = "UiTemplate")]
    pub ui_template: UiTemplate,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateHumanTaskUiResponse {
    /// <p>The Amazon Resource Name (ARN) of the human review workflow user interface you create.</p>
    #[serde(rename = "HumanTaskUiArn")]
    pub human_task_ui_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateHyperParameterTuningJobRequest {
    /// <p>The <a>HyperParameterTuningJobConfig</a> object that describes the tuning job, including the search strategy, the objective metric used to evaluate training jobs, ranges of parameters to search, and resource limits for the tuning job. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-how-it-works.html">How Hyperparameter Tuning Works</a>.</p>
    #[serde(rename = "HyperParameterTuningJobConfig")]
    pub hyper_parameter_tuning_job_config: HyperParameterTuningJobConfig,
    /// <p>The name of the tuning job. This name is the prefix for the names of all training jobs that this tuning job launches. The name must be unique within the same AWS account and AWS Region. The name must have 1 to 32 characters. Valid characters are a-z, A-Z, 0-9, and : + = @ _ % - (hyphen). The name is not case sensitive.</p>
    #[serde(rename = "HyperParameterTuningJobName")]
    pub hyper_parameter_tuning_job_name: String,
    /// <p>An array of key-value pairs. You can use tags to categorize your AWS resources in different ways, for example, by purpose, owner, or environment. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS Resources</a>.</p> <p>Tags that you specify for the tuning job are also added to all training jobs that the tuning job launches.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>The <a>HyperParameterTrainingJobDefinition</a> object that describes the training jobs that this tuning job launches, including static hyperparameters, input data configuration, output data configuration, resource configuration, and stopping condition.</p>
    #[serde(rename = "TrainingJobDefinition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_job_definition: Option<HyperParameterTrainingJobDefinition>,
    /// <p>A list of the <a>HyperParameterTrainingJobDefinition</a> objects launched for this tuning job.</p>
    #[serde(rename = "TrainingJobDefinitions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_job_definitions: Option<Vec<HyperParameterTrainingJobDefinition>>,
    /// <p><p>Specifies the configuration for starting the hyperparameter tuning job using one or more previous 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.</p> <p>All training jobs launched by the new hyperparameter tuning job are evaluated by using the objective metric. If you specify <code>IDENTICAL<em>DATA</em>AND_ALGORITHM</code> as the <code>WarmStartType</code> value for the warm start configuration, the training job that performs the best in the new tuning job 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.</p> <note> <p>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.</p> </note></p>
    #[serde(rename = "WarmStartConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub warm_start_config: Option<HyperParameterTuningJobWarmStartConfig>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateHyperParameterTuningJobResponse {
    /// <p>The Amazon Resource Name (ARN) of the tuning job. Amazon SageMaker assigns an ARN to a hyperparameter tuning job when you create it.</p>
    #[serde(rename = "HyperParameterTuningJobArn")]
    pub hyper_parameter_tuning_job_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateImageRequest {
    /// <p>The description of the image.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The display name of the image. If not provided, <code>ImageName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>The name of the image. Must be unique to your account.</p>
    #[serde(rename = "ImageName")]
    pub image_name: String,
    /// <p>The Amazon Resource Name (ARN) of an IAM role that enables Amazon SageMaker to perform tasks on your behalf.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    /// <p>A list of tags to apply to the image.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateImageResponse {
    /// <p>The Amazon Resource Name (ARN) of the image.</p>
    #[serde(rename = "ImageArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateImageVersionRequest {
    /// <p>The registry path of the container image to use as the starting point for this version. The path is an Amazon Container Registry (ECR) URI in the following format:</p> <p> <code>&lt;acct-id&gt;.dkr.ecr.&lt;region&gt;.amazonaws.com/&lt;repo-name[:tag] or [@digest]&gt;</code> </p>
    #[serde(rename = "BaseImage")]
    pub base_image: String,
    /// <p>A unique ID. If not specified, the AWS CLI and AWS SDKs, such as the SDK for Python (Boto3), add a unique value to the call.</p>
    #[serde(rename = "ClientToken")]
    pub client_token: String,
    /// <p>The <code>ImageName</code> of the <code>Image</code> to create a version of.</p>
    #[serde(rename = "ImageName")]
    pub image_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateImageVersionResponse {
    /// <p>The Amazon Resource Name (ARN) of the image version.</p>
    #[serde(rename = "ImageVersionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_version_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLabelingJobRequest {
    /// <p>Configures the labeling task and how it is presented to workers; including, but not limited to price, keywords, and batch size (task count).</p>
    #[serde(rename = "HumanTaskConfig")]
    pub human_task_config: HumanTaskConfig,
    /// <p>Input data for the labeling job, such as the Amazon S3 location of the data objects and the location of the manifest file that describes the data objects.</p>
    #[serde(rename = "InputConfig")]
    pub input_config: LabelingJobInputConfig,
    /// <p>The attribute name to use for the label in the output manifest file. This is the key for the key/value pair formed with the label that a worker assigns to the object. The name can't end with "-metadata". If you are running a semantic segmentation labeling job, the attribute name must end with "-ref". If you are running any other kind of labeling job, the attribute name must not end with "-ref".</p>
    #[serde(rename = "LabelAttributeName")]
    pub label_attribute_name: String,
    /// <p>The S3 URI of the file that defines the categories used to label the data objects.</p> <p>For 3D point cloud task types, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-point-cloud-label-category-config.html">Create a Labeling Category Configuration File for 3D Point Cloud Labeling Jobs</a>. </p> <p>For all other <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-task-types.html">built-in task types</a> and <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-custom-templates.html">custom tasks</a>, your label category configuration file must be a JSON file in the following format. Identify the labels you want to use by replacing <code>label_1</code>, <code>label_2</code>,<code>...</code>,<code>label_n</code> with your label categories.</p> <p> <code>{</code> </p> <p> <code> "document-version": "2018-11-28"</code> </p> <p> <code> "labels": [</code> </p> <p> <code> {</code> </p> <p> <code> "label": "<i>label_1</i>"</code> </p> <p> <code> },</code> </p> <p> <code> {</code> </p> <p> <code> "label": "<i>label_2</i>"</code> </p> <p> <code> },</code> </p> <p> <code> ...</code> </p> <p> <code> {</code> </p> <p> <code> "label": "<i>label_n</i>"</code> </p> <p> <code> }</code> </p> <p> <code> ]</code> </p> <p> <code>}</code> </p>
    #[serde(rename = "LabelCategoryConfigS3Uri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub label_category_config_s3_uri: Option<String>,
    /// <p>Configures the information required to perform automated data labeling.</p>
    #[serde(rename = "LabelingJobAlgorithmsConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub labeling_job_algorithms_config: Option<LabelingJobAlgorithmsConfig>,
    /// <p>The name of the labeling job. This name is used to identify the job in a list of labeling jobs.</p>
    #[serde(rename = "LabelingJobName")]
    pub labeling_job_name: String,
    /// <p>The location of the output data and the AWS Key Management Service key ID for the key used to encrypt the output data, if any.</p>
    #[serde(rename = "OutputConfig")]
    pub output_config: LabelingJobOutputConfig,
    /// <p>The Amazon Resource Number (ARN) that Amazon SageMaker assumes to perform tasks on your behalf during data labeling. You must grant this role the necessary permissions so that Amazon SageMaker can successfully complete data labeling.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    /// <p>A set of conditions for stopping the 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.</p>
    #[serde(rename = "StoppingConditions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopping_conditions: Option<LabelingJobStoppingConditions>,
    /// <p>An array of key/value pairs. For more information, see <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-what">Using Cost Allocation Tags</a> in the <i>AWS Billing and Cost Management User Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLabelingJobResponse {
    /// <p>The Amazon Resource Name (ARN) of the labeling job. You use this ARN to identify the labeling job.</p>
    #[serde(rename = "LabelingJobArn")]
    pub labeling_job_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateModelBiasJobDefinitionRequest {
    /// <p>The name of the bias job definition. The name must be unique within an AWS Region in the AWS account.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
    #[serde(rename = "JobResources")]
    pub job_resources: MonitoringResources,
    /// <p>Configures the model bias job to run a specified Docker container image.</p>
    #[serde(rename = "ModelBiasAppSpecification")]
    pub model_bias_app_specification: ModelBiasAppSpecification,
    /// <p>The baseline configuration for a model bias job.</p>
    #[serde(rename = "ModelBiasBaselineConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_bias_baseline_config: Option<ModelBiasBaselineConfig>,
    /// <p>Inputs for the model bias job.</p>
    #[serde(rename = "ModelBiasJobInput")]
    pub model_bias_job_input: ModelBiasJobInput,
    #[serde(rename = "ModelBiasJobOutputConfig")]
    pub model_bias_job_output_config: MonitoringOutputConfig,
    /// <p>Networking options for a model bias job.</p>
    #[serde(rename = "NetworkConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub network_config: Option<MonitoringNetworkConfig>,
    /// <p>The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume to perform tasks on your behalf.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    #[serde(rename = "StoppingCondition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopping_condition: Option<MonitoringStoppingCondition>,
    /// <p>(Optional) An array of key-value pairs. For more information, see <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-whatURL">Using Cost Allocation Tags</a> in the <i>AWS Billing and Cost Management User Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateModelBiasJobDefinitionResponse {
    /// <p>The Amazon Resource Name (ARN) of the model bias job.</p>
    #[serde(rename = "JobDefinitionArn")]
    pub job_definition_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateModelExplainabilityJobDefinitionRequest {
    /// <p> The name of the model explainability job definition. The name must be unique within an AWS Region in the AWS account.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
    #[serde(rename = "JobResources")]
    pub job_resources: MonitoringResources,
    /// <p>Configures the model explainability job to run a specified Docker container image.</p>
    #[serde(rename = "ModelExplainabilityAppSpecification")]
    pub model_explainability_app_specification: ModelExplainabilityAppSpecification,
    /// <p>The baseline configuration for a model explainability job.</p>
    #[serde(rename = "ModelExplainabilityBaselineConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_explainability_baseline_config: Option<ModelExplainabilityBaselineConfig>,
    /// <p>Inputs for the model explainability job.</p>
    #[serde(rename = "ModelExplainabilityJobInput")]
    pub model_explainability_job_input: ModelExplainabilityJobInput,
    #[serde(rename = "ModelExplainabilityJobOutputConfig")]
    pub model_explainability_job_output_config: MonitoringOutputConfig,
    /// <p>Networking options for a model explainability job.</p>
    #[serde(rename = "NetworkConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub network_config: Option<MonitoringNetworkConfig>,
    /// <p>The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume to perform tasks on your behalf.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    #[serde(rename = "StoppingCondition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopping_condition: Option<MonitoringStoppingCondition>,
    /// <p>(Optional) An array of key-value pairs. For more information, see <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-whatURL">Using Cost Allocation Tags</a> in the <i>AWS Billing and Cost Management User Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateModelExplainabilityJobDefinitionResponse {
    /// <p>The Amazon Resource Name (ARN) of the model explainability job.</p>
    #[serde(rename = "JobDefinitionArn")]
    pub job_definition_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateModelInput {
    /// <p>Specifies the containers in the inference pipeline.</p>
    #[serde(rename = "Containers")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub containers: Option<Vec<ContainerDefinition>>,
    /// <p>Isolates the model container. No inbound or outbound network calls can be made to or from the model container.</p>
    #[serde(rename = "EnableNetworkIsolation")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_network_isolation: Option<bool>,
    /// <p><p>The Amazon Resource Name (ARN) of the IAM role that Amazon SageMaker can assume to access model artifacts and docker image for deployment on ML compute instances or for batch transform jobs. Deploying on ML compute instances is part of model hosting. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html">Amazon SageMaker Roles</a>. </p> <note> <p>To be able to pass this role to Amazon SageMaker, the caller of this API must have the <code>iam:PassRole</code> permission.</p> </note></p>
    #[serde(rename = "ExecutionRoleArn")]
    pub execution_role_arn: String,
    /// <p>The name of the new model.</p>
    #[serde(rename = "ModelName")]
    pub model_name: String,
    /// <p>The location of the primary docker image containing inference code, associated artifacts, and custom environment map that the inference code uses when the model is deployed for predictions. </p>
    #[serde(rename = "PrimaryContainer")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub primary_container: Option<ContainerDefinition>,
    /// <p>An array of key-value pairs. You can use tags to categorize your AWS resources in different ways, for example, by purpose, owner, or environment. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS Resources</a>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>A <a>VpcConfig</a> object that specifies the VPC that you want your model to connect to. Control access to and from your model container by configuring the VPC. <code>VpcConfig</code> is used in hosting services and in batch transform. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/host-vpc.html">Protect Endpoints by Using an Amazon Virtual Private Cloud</a> and <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/batch-vpc.html">Protect Data in Batch Transform Jobs by Using an Amazon Virtual Private Cloud</a>.</p>
    #[serde(rename = "VpcConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpc_config: Option<VpcConfig>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateModelOutput {
    /// <p>The ARN of the model created in Amazon SageMaker.</p>
    #[serde(rename = "ModelArn")]
    pub model_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateModelPackageGroupInput {
    /// <p>A description for the model group.</p>
    #[serde(rename = "ModelPackageGroupDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_group_description: Option<String>,
    /// <p>The name of the model group.</p>
    #[serde(rename = "ModelPackageGroupName")]
    pub model_package_group_name: String,
    /// <p>A list of key value pairs associated with the model group. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS resources</a> in the <i>AWS General Reference Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateModelPackageGroupOutput {
    /// <p>The Amazon Resource Name (ARN) of the model group.</p>
    #[serde(rename = "ModelPackageGroupArn")]
    pub model_package_group_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateModelPackageInput {
    /// <p>Whether to certify the model package for listing on AWS Marketplace.</p> <p>This parameter is optional for unversioned models, and does not apply to versioned models.</p>
    #[serde(rename = "CertifyForMarketplace")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub certify_for_marketplace: Option<bool>,
    /// <p>A unique token that guarantees that the call to this API is idempotent.</p>
    #[serde(rename = "ClientToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client_token: Option<String>,
    /// <p><p>Specifies details about inference jobs that can be run with models based on this model package, including the following:</p> <ul> <li> <p>The Amazon ECR paths of containers that contain the inference code and model artifacts.</p> </li> <li> <p>The instance types that the model package supports for transform jobs and real-time endpoints used for inference.</p> </li> <li> <p>The input and output content formats that the model package supports for inference.</p> </li> </ul></p>
    #[serde(rename = "InferenceSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inference_specification: Option<InferenceSpecification>,
    #[serde(rename = "MetadataProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_properties: Option<MetadataProperties>,
    /// <p>Whether the model is approved for deployment.</p> <p>This parameter is optional for versioned models, and does not apply to unversioned models.</p> <p>For versioned models, the value of this parameter must be set to <code>Approved</code> to deploy the model.</p>
    #[serde(rename = "ModelApprovalStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_approval_status: Option<String>,
    /// <p>A structure that contains model metrics reports.</p>
    #[serde(rename = "ModelMetrics")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_metrics: Option<ModelMetrics>,
    /// <p>A description of the model package.</p>
    #[serde(rename = "ModelPackageDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_description: Option<String>,
    /// <p>The name of the model group that this model version belongs to.</p> <p>This parameter is required for versioned models, and does not apply to unversioned models.</p>
    #[serde(rename = "ModelPackageGroupName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_group_name: Option<String>,
    /// <p>The name of the model package. The name must have 1 to 63 characters. Valid characters are a-z, A-Z, 0-9, and - (hyphen).</p> <p>This parameter is required for unversioned models. It is not applicable to versioned models.</p>
    #[serde(rename = "ModelPackageName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_name: Option<String>,
    /// <p>Details about the algorithm that was used to create the model package.</p>
    #[serde(rename = "SourceAlgorithmSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_algorithm_specification: Option<SourceAlgorithmSpecification>,
    /// <p>A list of key value pairs associated with the model. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS resources</a> in the <i>AWS General Reference Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>Specifies configurations for one or more transform jobs that Amazon SageMaker runs to test the model package.</p>
    #[serde(rename = "ValidationSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub validation_specification: Option<ModelPackageValidationSpecification>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateModelPackageOutput {
    /// <p>The Amazon Resource Name (ARN) of the new model package.</p>
    #[serde(rename = "ModelPackageArn")]
    pub model_package_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateModelQualityJobDefinitionRequest {
    /// <p>The name of the monitoring job definition.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
    #[serde(rename = "JobResources")]
    pub job_resources: MonitoringResources,
    /// <p>The container that runs the monitoring job.</p>
    #[serde(rename = "ModelQualityAppSpecification")]
    pub model_quality_app_specification: ModelQualityAppSpecification,
    /// <p>Specifies the constraints and baselines for the monitoring job.</p>
    #[serde(rename = "ModelQualityBaselineConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_quality_baseline_config: Option<ModelQualityBaselineConfig>,
    /// <p>A list of the inputs that are monitored. Currently endpoints are supported.</p>
    #[serde(rename = "ModelQualityJobInput")]
    pub model_quality_job_input: ModelQualityJobInput,
    #[serde(rename = "ModelQualityJobOutputConfig")]
    pub model_quality_job_output_config: MonitoringOutputConfig,
    /// <p>Specifies the network configuration for the monitoring job.</p>
    #[serde(rename = "NetworkConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub network_config: Option<MonitoringNetworkConfig>,
    /// <p>The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume to perform tasks on your behalf.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    #[serde(rename = "StoppingCondition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopping_condition: Option<MonitoringStoppingCondition>,
    /// <p>(Optional) An array of key-value pairs. For more information, see <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-whatURL">Using Cost Allocation Tags</a> in the <i>AWS Billing and Cost Management User Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateModelQualityJobDefinitionResponse {
    /// <p>The Amazon Resource Name (ARN) of the model quality monitoring job.</p>
    #[serde(rename = "JobDefinitionArn")]
    pub job_definition_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateMonitoringScheduleRequest {
    /// <p>The configuration object that specifies the monitoring schedule and defines the monitoring job.</p>
    #[serde(rename = "MonitoringScheduleConfig")]
    pub monitoring_schedule_config: MonitoringScheduleConfig,
    /// <p>The name of the monitoring schedule. The name must be unique within an AWS Region within an AWS account.</p>
    #[serde(rename = "MonitoringScheduleName")]
    pub monitoring_schedule_name: String,
    /// <p>(Optional) An array of key-value pairs. For more information, see <a href=" https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-whatURL">Using Cost Allocation Tags</a> in the <i>AWS Billing and Cost Management User Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateMonitoringScheduleResponse {
    /// <p>The Amazon Resource Name (ARN) of the monitoring schedule.</p>
    #[serde(rename = "MonitoringScheduleArn")]
    pub monitoring_schedule_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateNotebookInstanceInput {
    /// <p>A list of Elastic Inference (EI) instance types to associate with this notebook instance. Currently, only one instance type can be associated with a notebook instance. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/ei.html">Using Elastic Inference in Amazon SageMaker</a>.</p>
    #[serde(rename = "AcceleratorTypes")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accelerator_types: Option<Vec<String>>,
    /// <p>An array of up to three Git repositories to associate with the notebook instance. These can be either the names of Git repositories stored as resources in your account, or the URL of Git repositories in <a href="https://docs.aws.amazon.com/codecommit/latest/userguide/welcome.html">AWS CodeCommit</a> or in any other Git repository. These repositories are cloned at the same level as the default repository of your notebook instance. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/nbi-git-repo.html">Associating Git Repositories with Amazon SageMaker Notebook Instances</a>.</p>
    #[serde(rename = "AdditionalCodeRepositories")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub additional_code_repositories: Option<Vec<String>>,
    /// <p>A Git repository to associate with the notebook instance as its default code repository. This can be either the name of a Git repository stored as a resource in your account, or the URL of a Git repository in <a href="https://docs.aws.amazon.com/codecommit/latest/userguide/welcome.html">AWS CodeCommit</a> or in any other Git repository. When you open a notebook instance, it opens in the directory that contains this repository. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/nbi-git-repo.html">Associating Git Repositories with Amazon SageMaker Notebook Instances</a>.</p>
    #[serde(rename = "DefaultCodeRepository")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_code_repository: Option<String>,
    /// <p>Sets whether Amazon SageMaker provides internet access to the notebook instance. If you set this to <code>Disabled</code> this notebook instance will be able to access resources only in your VPC, and will not be able to connect to Amazon SageMaker training and endpoint services unless your configure a NAT Gateway in your VPC.</p> <p>For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/appendix-additional-considerations.html#appendix-notebook-and-internet-access">Notebook Instances Are Internet-Enabled by Default</a>. You can set the value of this parameter to <code>Disabled</code> only if you set a value for the <code>SubnetId</code> parameter.</p>
    #[serde(rename = "DirectInternetAccess")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub direct_internet_access: Option<String>,
    /// <p>The type of ML compute instance to launch for the notebook instance.</p>
    #[serde(rename = "InstanceType")]
    pub instance_type: String,
    /// <p>The Amazon Resource Name (ARN) of a AWS Key Management Service key that Amazon SageMaker uses to encrypt data on the storage volume attached to your notebook instance. The KMS key you provide must be enabled. For information, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/enabling-keys.html">Enabling and Disabling Keys</a> in the <i>AWS Key Management Service Developer Guide</i>.</p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>The name of a lifecycle configuration to associate with the notebook instance. For information about lifestyle configurations, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/notebook-lifecycle-config.html">Step 2.1: (Optional) Customize a Notebook Instance</a>.</p>
    #[serde(rename = "LifecycleConfigName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lifecycle_config_name: Option<String>,
    /// <p>The name of the new notebook instance.</p>
    #[serde(rename = "NotebookInstanceName")]
    pub notebook_instance_name: String,
    /// <p><p> When you send any requests to AWS resources from the notebook instance, Amazon SageMaker assumes this role to perform tasks on your behalf. You must grant this role necessary permissions so Amazon SageMaker can perform these tasks. The policy must allow the Amazon SageMaker service principal (sagemaker.amazonaws.com) permissions to assume this role. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html">Amazon SageMaker Roles</a>. </p> <note> <p>To be able to pass this role to Amazon SageMaker, the caller of this API must have the <code>iam:PassRole</code> permission.</p> </note></p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    /// <p><p>Whether root access is enabled or disabled for users of the notebook instance. The default value is <code>Enabled</code>.</p> <note> <p>Lifecycle configurations need root access to be able to set up a notebook instance. Because of this, lifecycle configurations associated with a notebook instance always run with root access even if you disable root access for users.</p> </note></p>
    #[serde(rename = "RootAccess")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub root_access: Option<String>,
    /// <p>The VPC security group IDs, in the form sg-xxxxxxxx. The security groups must be for the same VPC as specified in the subnet. </p>
    #[serde(rename = "SecurityGroupIds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub security_group_ids: Option<Vec<String>>,
    /// <p>The ID of the subnet in a VPC to which you would like to have a connectivity from your ML compute instance. </p>
    #[serde(rename = "SubnetId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subnet_id: Option<String>,
    /// <p>An array of key-value pairs. You can use tags to categorize your AWS resources in different ways, for example, by purpose, owner, or environment. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS Resources</a>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>The size, in GB, of the ML storage volume to attach to the notebook instance. The default value is 5 GB.</p>
    #[serde(rename = "VolumeSizeInGB")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume_size_in_gb: Option<i64>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateNotebookInstanceLifecycleConfigInput {
    /// <p>The name of the lifecycle configuration.</p>
    #[serde(rename = "NotebookInstanceLifecycleConfigName")]
    pub notebook_instance_lifecycle_config_name: String,
    /// <p>A shell script that runs only once, when you create a notebook instance. The shell script must be a base64-encoded string.</p>
    #[serde(rename = "OnCreate")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub on_create: Option<Vec<NotebookInstanceLifecycleHook>>,
    /// <p>A shell script that runs every time you start a notebook instance, including when you create the notebook instance. The shell script must be a base64-encoded string.</p>
    #[serde(rename = "OnStart")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub on_start: Option<Vec<NotebookInstanceLifecycleHook>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateNotebookInstanceLifecycleConfigOutput {
    /// <p>The Amazon Resource Name (ARN) of the lifecycle configuration.</p>
    #[serde(rename = "NotebookInstanceLifecycleConfigArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_instance_lifecycle_config_arn: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateNotebookInstanceOutput {
    /// <p>The Amazon Resource Name (ARN) of the notebook instance. </p>
    #[serde(rename = "NotebookInstanceArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_instance_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePipelineRequest {
    /// <p>A unique, case-sensitive identifier that you provide to ensure the idempotency of the operation. An idempotent operation completes no more than one time.</p>
    #[serde(rename = "ClientRequestToken")]
    pub client_request_token: String,
    /// <p>The JSON pipeline definition of the pipeline.</p>
    #[serde(rename = "PipelineDefinition")]
    pub pipeline_definition: String,
    /// <p>A description of the pipeline.</p>
    #[serde(rename = "PipelineDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_description: Option<String>,
    /// <p>The display name of the pipeline.</p>
    #[serde(rename = "PipelineDisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_display_name: Option<String>,
    /// <p>The name of the pipeline.</p>
    #[serde(rename = "PipelineName")]
    pub pipeline_name: String,
    /// <p>The Amazon Resource Name (ARN) of the role used by the pipeline to access and create resources.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    /// <p>A list of tags to apply to the created pipeline.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreatePipelineResponse {
    /// <p>The Amazon Resource Name (ARN) of the created pipeline.</p>
    #[serde(rename = "PipelineArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePresignedDomainUrlRequest {
    /// <p>The domain ID.</p>
    #[serde(rename = "DomainId")]
    pub domain_id: String,
    /// <p>The session expiration duration in seconds.</p>
    #[serde(rename = "SessionExpirationDurationInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub session_expiration_duration_in_seconds: Option<i64>,
    /// <p>The name of the UserProfile to sign-in as.</p>
    #[serde(rename = "UserProfileName")]
    pub user_profile_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreatePresignedDomainUrlResponse {
    /// <p>The presigned URL.</p>
    #[serde(rename = "AuthorizedUrl")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub authorized_url: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePresignedNotebookInstanceUrlInput {
    /// <p>The name of the notebook instance.</p>
    #[serde(rename = "NotebookInstanceName")]
    pub notebook_instance_name: String,
    /// <p>The duration of the session, in seconds. The default is 12 hours.</p>
    #[serde(rename = "SessionExpirationDurationInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub session_expiration_duration_in_seconds: Option<i64>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreatePresignedNotebookInstanceUrlOutput {
    /// <p>A JSON object that contains the URL string. </p>
    #[serde(rename = "AuthorizedUrl")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub authorized_url: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateProcessingJobRequest {
    /// <p>Configures the processing job to run a specified Docker container image.</p>
    #[serde(rename = "AppSpecification")]
    pub app_specification: AppSpecification,
    /// <p>Sets the environment variables in the Docker container.</p>
    #[serde(rename = "Environment")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub environment: Option<::std::collections::HashMap<String, String>>,
    #[serde(rename = "ExperimentConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_config: Option<ExperimentConfig>,
    /// <p>Networking options for a processing job.</p>
    #[serde(rename = "NetworkConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub network_config: Option<NetworkConfig>,
    /// <p>List of input configurations for the processing job.</p>
    #[serde(rename = "ProcessingInputs")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_inputs: Option<Vec<ProcessingInput>>,
    /// <p> The name of the processing job. The name must be unique within an AWS Region in the AWS account.</p>
    #[serde(rename = "ProcessingJobName")]
    pub processing_job_name: String,
    /// <p>Output configuration for the processing job.</p>
    #[serde(rename = "ProcessingOutputConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_output_config: Option<ProcessingOutputConfig>,
    /// <p>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.</p>
    #[serde(rename = "ProcessingResources")]
    pub processing_resources: ProcessingResources,
    /// <p>The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume to perform tasks on your behalf.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    /// <p>The time limit for how long the processing job is allowed to run.</p>
    #[serde(rename = "StoppingCondition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopping_condition: Option<ProcessingStoppingCondition>,
    /// <p>(Optional) An array of key-value pairs. For more information, see <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-whatURL">Using Cost Allocation Tags</a> in the <i>AWS Billing and Cost Management User Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateProcessingJobResponse {
    /// <p>The Amazon Resource Name (ARN) of the processing job.</p>
    #[serde(rename = "ProcessingJobArn")]
    pub processing_job_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateProjectInput {
    /// <p>A description for the project.</p>
    #[serde(rename = "ProjectDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub project_description: Option<String>,
    /// <p>The name of the project.</p>
    #[serde(rename = "ProjectName")]
    pub project_name: String,
    /// <p>The product ID and provisioning artifact ID to provision a service catalog. For information, see <a href="https://docs.aws.amazon.com/servicecatalog/latest/adminguide/introduction.html">What is AWS Service Catalog</a>.</p>
    #[serde(rename = "ServiceCatalogProvisioningDetails")]
    pub service_catalog_provisioning_details: ServiceCatalogProvisioningDetails,
    /// <p>An array of key-value pairs that you want to use to organize and track your AWS resource costs. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS resources</a> in the <i>AWS General Reference Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateProjectOutput {
    /// <p>The Amazon Resource Name (ARN) of the project.</p>
    #[serde(rename = "ProjectArn")]
    pub project_arn: String,
    /// <p>The ID of the new project.</p>
    #[serde(rename = "ProjectId")]
    pub project_id: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTrainingJobRequest {
    /// <p>The registry path of the Docker image that contains the training algorithm and algorithm-specific metadata, including the input mode. For more information about algorithms provided by Amazon SageMaker, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html">Algorithms</a>. For information about providing your own algorithms, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms.html">Using Your Own Algorithms with Amazon SageMaker</a>. </p>
    #[serde(rename = "AlgorithmSpecification")]
    pub algorithm_specification: AlgorithmSpecification,
    /// <p>Contains information about the output location for managed spot training checkpoint data.</p>
    #[serde(rename = "CheckpointConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub checkpoint_config: Option<CheckpointConfig>,
    #[serde(rename = "DebugHookConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub debug_hook_config: Option<DebugHookConfig>,
    /// <p>Configuration information for Debugger rules for debugging output tensors.</p>
    #[serde(rename = "DebugRuleConfigurations")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub debug_rule_configurations: Option<Vec<DebugRuleConfiguration>>,
    /// <p>To encrypt all communications between ML compute instances in distributed training, choose <code>True</code>. Encryption provides greater security for distributed training, but training might take longer. How long it takes depends on the amount of communication between compute instances, especially if you use a deep learning algorithm in distributed training. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/train-encrypt.html">Protect Communications Between ML Compute Instances in a Distributed Training Job</a>.</p>
    #[serde(rename = "EnableInterContainerTrafficEncryption")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_inter_container_traffic_encryption: Option<bool>,
    /// <p>To train models using managed spot training, choose <code>True</code>. Managed spot training provides a fully managed and scalable infrastructure for training machine learning models. this option is useful when training jobs can be interrupted and when there is flexibility when the training job is run. </p> <p>The complete and intermediate results of jobs are stored in an Amazon S3 bucket, and can be used as a starting point to train models incrementally. Amazon SageMaker provides metrics and logs in CloudWatch. They can be used to see when managed spot training jobs are running, interrupted, resumed, or completed. </p>
    #[serde(rename = "EnableManagedSpotTraining")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_managed_spot_training: Option<bool>,
    /// <p>Isolates the training container. No inbound or outbound network calls can be made, except for calls between peers within a training cluster for distributed training. If you enable network isolation for training jobs that are configured to use a VPC, Amazon SageMaker downloads and uploads customer data and model artifacts through the specified VPC, but the training container does not have network access.</p>
    #[serde(rename = "EnableNetworkIsolation")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_network_isolation: Option<bool>,
    #[serde(rename = "ExperimentConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_config: Option<ExperimentConfig>,
    /// <p>Algorithm-specific parameters that influence the quality of the model. You set hyperparameters before you start the learning process. For a list of hyperparameters for each training algorithm provided by Amazon SageMaker, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html">Algorithms</a>. </p> <p>You can specify a maximum of 100 hyperparameters. Each hyperparameter is a key-value pair. Each key and value is limited to 256 characters, as specified by the <code>Length Constraint</code>. </p>
    #[serde(rename = "HyperParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hyper_parameters: Option<::std::collections::HashMap<String, String>>,
    /// <p>An array of <code>Channel</code> objects. Each channel is a named input source. <code>InputDataConfig</code> describes the input data and its location. </p> <p>Algorithms can accept input data from one or more channels. For example, an algorithm might have two channels of input data, <code>training_data</code> and <code>validation_data</code>. The configuration for each channel provides the S3, EFS, or FSx location where the input data is stored. It also provides information about the stored data: the MIME type, compression method, and whether the data is wrapped in RecordIO format. </p> <p>Depending on the input mode that the algorithm supports, Amazon SageMaker either copies input data files from an S3 bucket to a local directory in the Docker container, or makes it available as input streams. For example, if you specify an EFS location, input data files will be made available as input streams. They do not need to be downloaded.</p>
    #[serde(rename = "InputDataConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_data_config: Option<Vec<Channel>>,
    /// <p>Specifies the path to the S3 location where you want to store model artifacts. Amazon SageMaker creates subfolders for the artifacts. </p>
    #[serde(rename = "OutputDataConfig")]
    pub output_data_config: OutputDataConfig,
    #[serde(rename = "ProfilerConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub profiler_config: Option<ProfilerConfig>,
    /// <p>Configuration information for Debugger rules for profiling system and framework metrics.</p>
    #[serde(rename = "ProfilerRuleConfigurations")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub profiler_rule_configurations: Option<Vec<ProfilerRuleConfiguration>>,
    /// <p>The resources, including the ML compute instances and ML storage volumes, to use for model training. </p> <p>ML storage volumes store model artifacts and incremental states. Training algorithms might also use ML storage volumes for scratch space. If you want Amazon SageMaker to use the ML storage volume to store the training data, choose <code>File</code> as the <code>TrainingInputMode</code> in the algorithm specification. For distributed training algorithms, specify an instance count greater than 1.</p>
    #[serde(rename = "ResourceConfig")]
    pub resource_config: ResourceConfig,
    /// <p><p>The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume to perform tasks on your behalf. </p> <p>During model training, Amazon SageMaker needs your permission to read input data from an S3 bucket, download a Docker image that contains training code, write model artifacts to an S3 bucket, write logs to Amazon CloudWatch Logs, and publish metrics to Amazon CloudWatch. You grant permissions for all of these tasks to an IAM role. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html">Amazon SageMaker Roles</a>. </p> <note> <p>To be able to pass this role to Amazon SageMaker, the caller of this API must have the <code>iam:PassRole</code> permission.</p> </note></p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    /// <p>Specifies a limit to how long a model training job can run. When the job reaches the time limit, Amazon SageMaker ends the training job. Use this API to cap model training costs.</p> <p>To stop a job, Amazon SageMaker sends the algorithm the <code>SIGTERM</code> signal, 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. </p>
    #[serde(rename = "StoppingCondition")]
    pub stopping_condition: StoppingCondition,
    /// <p>An array of key-value pairs. You can use tags to categorize your AWS resources in different ways, for example, by purpose, owner, or environment. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS Resources</a>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    #[serde(rename = "TensorBoardOutputConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tensor_board_output_config: Option<TensorBoardOutputConfig>,
    /// <p>The name of the training job. The name must be unique within an AWS Region in an AWS account. </p>
    #[serde(rename = "TrainingJobName")]
    pub training_job_name: String,
    /// <p>A <a>VpcConfig</a> object that specifies the VPC that you want your training job to connect to. Control access to and from your training container by configuring the VPC. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/train-vpc.html">Protect Training Jobs by Using an Amazon Virtual Private Cloud</a>.</p>
    #[serde(rename = "VpcConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpc_config: Option<VpcConfig>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTrainingJobResponse {
    /// <p>The Amazon Resource Name (ARN) of the training job.</p>
    #[serde(rename = "TrainingJobArn")]
    pub training_job_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTransformJobRequest {
    /// <p>Specifies the number of records to include in a mini-batch for an HTTP inference request. A <i>record</i> <i/> is a single unit of input data that inference can be made on. For example, a single line in a CSV file is a record. </p> <p>To enable the batch strategy, you must set the <code>SplitType</code> property to <code>Line</code>, <code>RecordIO</code>, or <code>TFRecord</code>.</p> <p>To use only one record when making an HTTP invocation request to a container, set <code>BatchStrategy</code> to <code>SingleRecord</code> and <code>SplitType</code> to <code>Line</code>.</p> <p>To fit as many records in a mini-batch as can fit within the <code>MaxPayloadInMB</code> limit, set <code>BatchStrategy</code> to <code>MultiRecord</code> and <code>SplitType</code> to <code>Line</code>.</p>
    #[serde(rename = "BatchStrategy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub batch_strategy: Option<String>,
    /// <p>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 <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform-data-processing.html">Associate Prediction Results with their Corresponding Input Records</a>.</p>
    #[serde(rename = "DataProcessing")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data_processing: Option<DataProcessing>,
    /// <p>The environment variables to set in the Docker container. We support up to 16 key and values entries in the map.</p>
    #[serde(rename = "Environment")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub environment: Option<::std::collections::HashMap<String, String>>,
    #[serde(rename = "ExperimentConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_config: Option<ExperimentConfig>,
    /// <p>The maximum number of parallel requests that can be sent to each instance in a transform job. If <code>MaxConcurrentTransforms</code> is set to <code>0</code> or left unset, Amazon SageMaker checks the optional execution-parameters to determine the settings for your chosen algorithm. If the execution-parameters endpoint is not enabled, the default value is <code>1</code>. For more information on execution-parameters, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-batch-code.html#your-algorithms-batch-code-how-containe-serves-requests">How Containers Serve Requests</a>. For built-in algorithms, you don't need to set a value for <code>MaxConcurrentTransforms</code>.</p>
    #[serde(rename = "MaxConcurrentTransforms")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_concurrent_transforms: Option<i64>,
    /// <p>The maximum allowed size of the payload, in MB. A <i>payload</i> is the data portion of a record (without metadata). The value in <code>MaxPayloadInMB</code> must be greater than, or equal to, the size of a single record. To estimate the size of a record in MB, divide the size of your dataset by the number of records. To ensure that the records fit within the maximum payload size, we recommend using a slightly larger value. The default value is <code>6</code> MB. </p> <p>For cases where the payload might be arbitrarily large and is transmitted using HTTP chunked encoding, set the value to <code>0</code>. This feature works only in supported algorithms. Currently, Amazon SageMaker built-in algorithms do not support HTTP chunked encoding.</p>
    #[serde(rename = "MaxPayloadInMB")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_payload_in_mb: Option<i64>,
    /// <p>Configures the timeout and maximum number of retries for processing a transform job invocation.</p>
    #[serde(rename = "ModelClientConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_client_config: Option<ModelClientConfig>,
    /// <p>The name of the model that you want to use for the transform job. <code>ModelName</code> must be the name of an existing Amazon SageMaker model within an AWS Region in an AWS account.</p>
    #[serde(rename = "ModelName")]
    pub model_name: String,
    /// <p>(Optional) An array of key-value pairs. For more information, see <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-what">Using Cost Allocation Tags</a> in the <i>AWS Billing and Cost Management User Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>Describes the input source and the way the transform job consumes it.</p>
    #[serde(rename = "TransformInput")]
    pub transform_input: TransformInput,
    /// <p>The name of the transform job. The name must be unique within an AWS Region in an AWS account. </p>
    #[serde(rename = "TransformJobName")]
    pub transform_job_name: String,
    /// <p>Describes the results of the transform job.</p>
    #[serde(rename = "TransformOutput")]
    pub transform_output: TransformOutput,
    /// <p>Describes the resources, including ML instance types and ML instance count, to use for the transform job.</p>
    #[serde(rename = "TransformResources")]
    pub transform_resources: TransformResources,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTransformJobResponse {
    /// <p>The Amazon Resource Name (ARN) of the transform job.</p>
    #[serde(rename = "TransformJobArn")]
    pub transform_job_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTrialComponentRequest {
    /// <p>The name of the component as displayed. The name doesn't need to be unique. If <code>DisplayName</code> isn't specified, <code>TrialComponentName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>When the component ended.</p>
    #[serde(rename = "EndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub end_time: Option<f64>,
    /// <p>The input artifacts for the component. Examples of input artifacts are datasets, algorithms, hyperparameters, source code, and instance types.</p>
    #[serde(rename = "InputArtifacts")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_artifacts: Option<::std::collections::HashMap<String, TrialComponentArtifact>>,
    #[serde(rename = "MetadataProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_properties: Option<MetadataProperties>,
    /// <p>The output artifacts for the component. Examples of output artifacts are metrics, snapshots, logs, and images.</p>
    #[serde(rename = "OutputArtifacts")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_artifacts: Option<::std::collections::HashMap<String, TrialComponentArtifact>>,
    /// <p>The hyperparameters for the component.</p>
    #[serde(rename = "Parameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parameters: Option<::std::collections::HashMap<String, TrialComponentParameterValue>>,
    /// <p>When the component started.</p>
    #[serde(rename = "StartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start_time: Option<f64>,
    /// <p><p>The status of the component. States include:</p> <ul> <li> <p>InProgress</p> </li> <li> <p>Completed</p> </li> <li> <p>Failed</p> </li> </ul></p>
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<TrialComponentStatus>,
    /// <p>A list of tags to associate with the component. You can use <a>Search</a> API to search on the tags.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>The name of the component. The name must be unique in your AWS account and is not case-sensitive.</p>
    #[serde(rename = "TrialComponentName")]
    pub trial_component_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTrialComponentResponse {
    /// <p>The Amazon Resource Name (ARN) of the trial component.</p>
    #[serde(rename = "TrialComponentArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTrialRequest {
    /// <p>The name of the trial as displayed. The name doesn't need to be unique. If <code>DisplayName</code> isn't specified, <code>TrialName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>The name of the experiment to associate the trial with.</p>
    #[serde(rename = "ExperimentName")]
    pub experiment_name: String,
    #[serde(rename = "MetadataProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_properties: Option<MetadataProperties>,
    /// <p>A list of tags to associate with the trial. You can use <a>Search</a> API to search on the tags.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>The name of the trial. The name must be unique in your AWS account and is not case-sensitive.</p>
    #[serde(rename = "TrialName")]
    pub trial_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTrialResponse {
    /// <p>The Amazon Resource Name (ARN) of the trial.</p>
    #[serde(rename = "TrialArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateUserProfileRequest {
    /// <p>The ID of the associated Domain.</p>
    #[serde(rename = "DomainId")]
    pub domain_id: String,
    /// <p>A specifier for the type of value specified in SingleSignOnUserValue. Currently, the only supported value is "UserName". If the Domain's AuthMode is SSO, this field is required. If the Domain's AuthMode is not SSO, this field cannot be specified. </p>
    #[serde(rename = "SingleSignOnUserIdentifier")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub single_sign_on_user_identifier: Option<String>,
    /// <p>The username of the associated AWS Single Sign-On User for this UserProfile. If the Domain's AuthMode is SSO, this field is required, and must match a valid username of a user in your directory. If the Domain's AuthMode is not SSO, this field cannot be specified. </p>
    #[serde(rename = "SingleSignOnUserValue")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub single_sign_on_user_value: Option<String>,
    /// <p>Each tag consists of a key and an optional value. Tag keys must be unique per resource.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>A name for the UserProfile.</p>
    #[serde(rename = "UserProfileName")]
    pub user_profile_name: String,
    /// <p>A collection of settings.</p>
    #[serde(rename = "UserSettings")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_settings: Option<UserSettings>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateUserProfileResponse {
    /// <p>The user profile Amazon Resource Name (ARN).</p>
    #[serde(rename = "UserProfileArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_profile_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateWorkforceRequest {
    /// <p>Use this parameter to configure an Amazon Cognito private workforce. A single Cognito workforce is created using and corresponds to a single <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html"> Amazon Cognito user pool</a>.</p> <p>Do not use <code>OidcConfig</code> if you specify values for <code>CognitoConfig</code>.</p>
    #[serde(rename = "CognitoConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cognito_config: Option<CognitoConfig>,
    /// <p>Use this parameter to configure a private workforce using your own OIDC Identity Provider.</p> <p>Do not use <code>CognitoConfig</code> if you specify values for <code>OidcConfig</code>.</p>
    #[serde(rename = "OidcConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub oidc_config: Option<OidcConfig>,
    #[serde(rename = "SourceIpConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_ip_config: Option<SourceIpConfig>,
    /// <p>An array of key-value pairs that contain metadata to help you categorize and organize our workforce. Each tag consists of a key and a value, both of which you define.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>The name of the private workforce.</p>
    #[serde(rename = "WorkforceName")]
    pub workforce_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateWorkforceResponse {
    /// <p>The Amazon Resource Name (ARN) of the workforce.</p>
    #[serde(rename = "WorkforceArn")]
    pub workforce_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateWorkteamRequest {
    /// <p>A description of the work team.</p>
    #[serde(rename = "Description")]
    pub description: String,
    /// <p>A list of <code>MemberDefinition</code> objects that contains objects that identify the workers that make up the work team. </p> <p>Workforces can be created using Amazon Cognito or your own OIDC Identity Provider (IdP). For private workforces created using Amazon Cognito use <code>CognitoMemberDefinition</code>. For workforces created using your own OIDC identity provider (IdP) use <code>OidcMemberDefinition</code>. Do not provide input for both of these parameters in a single request.</p> <p>For workforces created using Amazon Cognito, private work teams correspond to Amazon Cognito <i>user groups</i> within the user pool used to create a workforce. All of the <code>CognitoMemberDefinition</code> objects that make up the member definition must have the same <code>ClientId</code> and <code>UserPool</code> values. To add a Amazon Cognito user group to an existing worker pool, see <a href="">Adding groups to a User Pool</a>. For more information about user pools, see <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html">Amazon Cognito User Pools</a>.</p> <p>For workforces created using your own OIDC IdP, specify the user groups that you want to include in your private work team in <code>OidcMemberDefinition</code> by listing those groups in <code>Groups</code>.</p>
    #[serde(rename = "MemberDefinitions")]
    pub member_definitions: Vec<MemberDefinition>,
    /// <p>Configures notification of workers regarding available or expiring work items.</p>
    #[serde(rename = "NotificationConfiguration")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notification_configuration: Option<NotificationConfiguration>,
    /// <p>An array of key-value pairs.</p> <p>For more information, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-resource-tags.html">Resource Tag</a> and <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-what">Using Cost Allocation Tags</a> in the <i> AWS Billing and Cost Management User Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>The name of the workforce.</p>
    #[serde(rename = "WorkforceName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub workforce_name: Option<String>,
    /// <p>The name of the work team. Use this name to identify the work team.</p>
    #[serde(rename = "WorkteamName")]
    pub workteam_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateWorkteamResponse {
    /// <p>The Amazon Resource Name (ARN) of the work team. You can use this ARN to identify the work team.</p>
    #[serde(rename = "WorkteamArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub workteam_arn: Option<String>,
}

/// <p>A custom SageMaker image. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/studio-byoi.html">Bring your own SageMaker image</a>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CustomImage {
    /// <p>The name of the AppImageConfig.</p>
    #[serde(rename = "AppImageConfigName")]
    pub app_image_config_name: String,
    /// <p>The name of the CustomImage. Must be unique to your account.</p>
    #[serde(rename = "ImageName")]
    pub image_name: String,
    /// <p>The version number of the CustomImage.</p>
    #[serde(rename = "ImageVersionNumber")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_version_number: Option<i64>,
}

/// <p><p/></p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataCaptureConfig {
    /// <p><p/></p>
    #[serde(rename = "CaptureContentTypeHeader")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub capture_content_type_header: Option<CaptureContentTypeHeader>,
    /// <p><p/></p>
    #[serde(rename = "CaptureOptions")]
    pub capture_options: Vec<CaptureOption>,
    /// <p><p/></p>
    #[serde(rename = "DestinationS3Uri")]
    pub destination_s3_uri: String,
    /// <p><p/></p>
    #[serde(rename = "EnableCapture")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_capture: Option<bool>,
    /// <p><p/></p>
    #[serde(rename = "InitialSamplingPercentage")]
    pub initial_sampling_percentage: i64,
    /// <p><p/></p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
}

/// <p><p/></p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DataCaptureConfigSummary {
    /// <p><p/></p>
    #[serde(rename = "CaptureStatus")]
    pub capture_status: String,
    /// <p><p/></p>
    #[serde(rename = "CurrentSamplingPercentage")]
    pub current_sampling_percentage: i64,
    /// <p><p/></p>
    #[serde(rename = "DestinationS3Uri")]
    pub destination_s3_uri: String,
    /// <p><p/></p>
    #[serde(rename = "EnableCapture")]
    pub enable_capture: bool,
    /// <p><p/></p>
    #[serde(rename = "KmsKeyId")]
    pub kms_key_id: String,
}

/// <p>The meta data of the Glue table which serves as data catalog for the <code>OfflineStore</code>. </p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataCatalogConfig {
    /// <p>The name of the Glue table catalog.</p>
    #[serde(rename = "Catalog")]
    pub catalog: String,
    /// <p>The name of the Glue table database.</p>
    #[serde(rename = "Database")]
    pub database: String,
    /// <p>The name of the Glue table.</p>
    #[serde(rename = "TableName")]
    pub table_name: String,
}

/// <p>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 <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform-data-processing.html">Associate Prediction Results with their Corresponding Input Records</a>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataProcessing {
    /// <p>A <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform-data-processing.html#data-processing-operators">JSONPath</a> expression used to select a portion of the input data to pass to the algorithm. Use the <code>InputFilter</code> parameter to exclude fields, such as an ID column, from the input. If you want Amazon SageMaker to pass the entire input dataset to the algorithm, accept the default value <code>$</code>.</p> <p>Examples: <code>"$"</code>, <code>"$[1:]"</code>, <code>"$.features"</code> </p>
    #[serde(rename = "InputFilter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_filter: Option<String>,
    /// <p>Specifies the source of the data to join with the transformed data. The valid values are <code>None</code> and <code>Input</code>. The default value is <code>None</code>, which specifies not to join the input with the transformed data. If you want the batch transform job to join the original input data with the transformed data, set <code>JoinSource</code> to <code>Input</code>. </p> <p>For JSON or JSONLines objects, such as a JSON array, Amazon SageMaker adds the transformed data to the input JSON object in an attribute called <code>SageMakerOutput</code>. The joined result for JSON must be a key-value pair object. If the input is not a key-value pair object, Amazon SageMaker creates a new JSON file. In the new JSON file, and the input data is stored under the <code>SageMakerInput</code> key and the results are stored in <code>SageMakerOutput</code>.</p> <p>For CSV files, Amazon SageMaker combines the transformed data with the input data at the end of the input data and stores it in the output file. The joined data has the joined input data followed by the transformed data and the output is a CSV file. </p>
    #[serde(rename = "JoinSource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub join_source: Option<String>,
    /// <p>A <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform-data-processing.html#data-processing-operators">JSONPath</a> expression used to select a portion of the joined dataset to save in the output file for a batch transform job. If you want Amazon SageMaker to store the entire input dataset in the output file, leave the default value, <code>$</code>. If you specify indexes that aren't within the dimension size of the joined dataset, you get an error.</p> <p>Examples: <code>"$"</code>, <code>"$[0,5:]"</code>, <code>"$['id','SageMakerOutput']"</code> </p>
    #[serde(rename = "OutputFilter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_filter: Option<String>,
}

/// <p>Information about the container that a data quality monitoring job runs.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataQualityAppSpecification {
    /// <p>The arguments to send to the container that the monitoring job runs.</p>
    #[serde(rename = "ContainerArguments")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_arguments: Option<Vec<String>>,
    /// <p>The entrypoint for a container used to run a monitoring job.</p>
    #[serde(rename = "ContainerEntrypoint")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_entrypoint: Option<Vec<String>>,
    /// <p>Sets the environment variables in the container that the monitoring job runs.</p>
    #[serde(rename = "Environment")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub environment: Option<::std::collections::HashMap<String, String>>,
    /// <p>The container image that the data quality monitoring job runs.</p>
    #[serde(rename = "ImageUri")]
    pub image_uri: String,
    /// <p>An Amazon S3 URI to a script that is called after analysis has been performed. Applicable only for the built-in (first party) containers.</p>
    #[serde(rename = "PostAnalyticsProcessorSourceUri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub post_analytics_processor_source_uri: Option<String>,
    /// <p>An Amazon S3 URI to a script that is called per row prior to running analysis. It can base64 decode the payload and convert it into a flatted json so that the built-in container can use the converted data. Applicable only for the built-in (first party) containers.</p>
    #[serde(rename = "RecordPreprocessorSourceUri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub record_preprocessor_source_uri: Option<String>,
}

/// <p>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.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataQualityBaselineConfig {
    /// <p>The name of the job that performs baselining for the data quality monitoring job.</p>
    #[serde(rename = "BaseliningJobName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub baselining_job_name: Option<String>,
    #[serde(rename = "ConstraintsResource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub constraints_resource: Option<MonitoringConstraintsResource>,
    #[serde(rename = "StatisticsResource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub statistics_resource: Option<MonitoringStatisticsResource>,
}

/// <p>The input for the data quality monitoring job. Currently endpoints are supported for input.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataQualityJobInput {
    #[serde(rename = "EndpointInput")]
    pub endpoint_input: EndpointInput,
}

/// <p>Describes the location of the channel data.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataSource {
    /// <p>The file system that is associated with a channel.</p>
    #[serde(rename = "FileSystemDataSource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file_system_data_source: Option<FileSystemDataSource>,
    /// <p>The S3 location of the data source that is associated with a channel.</p>
    #[serde(rename = "S3DataSource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_data_source: Option<S3DataSource>,
}

/// <p>Configuration for Dataset Definition inputs. The Dataset Definition input must specify exactly one of either <code>AthenaDatasetDefinition</code> or <code>RedshiftDatasetDefinition</code> types.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DatasetDefinition {
    #[serde(rename = "AthenaDatasetDefinition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub athena_dataset_definition: Option<AthenaDatasetDefinition>,
    /// <p>Whether the generated dataset is <code>FullyReplicated</code> or <code>ShardedByS3Key</code> (default).</p>
    #[serde(rename = "DataDistributionType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data_distribution_type: Option<String>,
    /// <p>Whether to use <code>File</code> or <code>Pipe</code> input mode. In <code>File</code> (default) mode, Amazon SageMaker copies the data from the input source onto the local Amazon Elastic Block Store (Amazon EBS) volumes before starting your training algorithm. This is the most commonly used input mode. In <code>Pipe</code> mode, Amazon SageMaker streams input data from the source directly to your algorithm without using the EBS volume.</p>
    #[serde(rename = "InputMode")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_mode: Option<String>,
    /// <p>The local path where you want Amazon SageMaker to download the Dataset Definition inputs to run a processing job. <code>LocalPath</code> is an absolute path to the input data. This is a required parameter when <code>AppManaged</code> is <code>False</code> (default).</p>
    #[serde(rename = "LocalPath")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub local_path: Option<String>,
    #[serde(rename = "RedshiftDatasetDefinition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redshift_dataset_definition: Option<RedshiftDatasetDefinition>,
}

/// <p>Configuration information for the Debugger hook parameters, metric and tensor collections, and storage paths. To learn more about how to configure the <code>DebugHookConfig</code> parameter, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-createtrainingjob-api.html">Use the SageMaker and Debugger Configuration API Operations to Create, Update, and Debug Your Training Job</a>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DebugHookConfig {
    /// <p>Configuration information for Debugger tensor collections. To learn more about how to configure the <code>CollectionConfiguration</code> parameter, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-createtrainingjob-api.html">Use the SageMaker and Debugger Configuration API Operations to Create, Update, and Debug Your Training Job</a>. </p>
    #[serde(rename = "CollectionConfigurations")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub collection_configurations: Option<Vec<CollectionConfiguration>>,
    /// <p>Configuration information for the Debugger hook parameters.</p>
    #[serde(rename = "HookParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hook_parameters: Option<::std::collections::HashMap<String, String>>,
    /// <p>Path to local storage location for metrics and tensors. Defaults to <code>/opt/ml/output/tensors/</code>.</p>
    #[serde(rename = "LocalPath")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub local_path: Option<String>,
    /// <p>Path to Amazon S3 storage location for metrics and tensors.</p>
    #[serde(rename = "S3OutputPath")]
    pub s3_output_path: String,
}

/// <p>Configuration information for SageMaker Debugger rules for debugging. To learn more about how to configure the <code>DebugRuleConfiguration</code> parameter, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-createtrainingjob-api.html">Use the SageMaker and Debugger Configuration API Operations to Create, Update, and Debug Your Training Job</a>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DebugRuleConfiguration {
    /// <p>The instance type to deploy a Debugger custom rule for debugging a training job.</p>
    #[serde(rename = "InstanceType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub instance_type: Option<String>,
    /// <p>Path to local storage location for output of rules. Defaults to <code>/opt/ml/processing/output/rule/</code>.</p>
    #[serde(rename = "LocalPath")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub local_path: Option<String>,
    /// <p>The name of the rule configuration. It must be unique relative to other rule configuration names.</p>
    #[serde(rename = "RuleConfigurationName")]
    pub rule_configuration_name: String,
    /// <p>The Amazon Elastic Container (ECR) Image for the managed rule evaluation.</p>
    #[serde(rename = "RuleEvaluatorImage")]
    pub rule_evaluator_image: String,
    /// <p>Runtime configuration for rule container.</p>
    #[serde(rename = "RuleParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rule_parameters: Option<::std::collections::HashMap<String, String>>,
    /// <p>Path to Amazon S3 storage location for rules.</p>
    #[serde(rename = "S3OutputPath")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_output_path: Option<String>,
    /// <p>The size, in GB, of the ML storage volume attached to the processing instance.</p>
    #[serde(rename = "VolumeSizeInGB")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume_size_in_gb: Option<i64>,
}

/// <p>Information about the status of the rule evaluation.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DebugRuleEvaluationStatus {
    /// <p>Timestamp when the rule evaluation status was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The name of the rule configuration.</p>
    #[serde(rename = "RuleConfigurationName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rule_configuration_name: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the rule evaluation job.</p>
    #[serde(rename = "RuleEvaluationJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rule_evaluation_job_arn: Option<String>,
    /// <p>Status of the rule evaluation.</p>
    #[serde(rename = "RuleEvaluationStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rule_evaluation_status: Option<String>,
    /// <p>Details from the rule evaluation.</p>
    #[serde(rename = "StatusDetails")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_details: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteActionRequest {
    /// <p>The name of the action to delete.</p>
    #[serde(rename = "ActionName")]
    pub action_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteActionResponse {
    /// <p>The Amazon Resource Name (ARN) of the action.</p>
    #[serde(rename = "ActionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub action_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAlgorithmInput {
    /// <p>The name of the algorithm to delete.</p>
    #[serde(rename = "AlgorithmName")]
    pub algorithm_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAppImageConfigRequest {
    /// <p>The name of the AppImageConfig to delete.</p>
    #[serde(rename = "AppImageConfigName")]
    pub app_image_config_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAppRequest {
    /// <p>The name of the app.</p>
    #[serde(rename = "AppName")]
    pub app_name: String,
    /// <p>The type of app.</p>
    #[serde(rename = "AppType")]
    pub app_type: String,
    /// <p>The domain ID.</p>
    #[serde(rename = "DomainId")]
    pub domain_id: String,
    /// <p>The user profile name.</p>
    #[serde(rename = "UserProfileName")]
    pub user_profile_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteArtifactRequest {
    /// <p>The Amazon Resource Name (ARN) of the artifact to delete.</p>
    #[serde(rename = "ArtifactArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artifact_arn: Option<String>,
    /// <p>The URI of the source.</p>
    #[serde(rename = "Source")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<ArtifactSource>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteArtifactResponse {
    /// <p>The Amazon Resource Name (ARN) of the artifact.</p>
    #[serde(rename = "ArtifactArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artifact_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAssociationRequest {
    /// <p>The Amazon Resource Name (ARN) of the destination.</p>
    #[serde(rename = "DestinationArn")]
    pub destination_arn: String,
    /// <p>The ARN of the source.</p>
    #[serde(rename = "SourceArn")]
    pub source_arn: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteAssociationResponse {
    /// <p>The Amazon Resource Name (ARN) of the destination.</p>
    #[serde(rename = "DestinationArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub destination_arn: Option<String>,
    /// <p>The ARN of the source.</p>
    #[serde(rename = "SourceArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCodeRepositoryInput {
    /// <p>The name of the Git repository to delete.</p>
    #[serde(rename = "CodeRepositoryName")]
    pub code_repository_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteContextRequest {
    /// <p>The name of the context to delete.</p>
    #[serde(rename = "ContextName")]
    pub context_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteContextResponse {
    /// <p>The Amazon Resource Name (ARN) of the context.</p>
    #[serde(rename = "ContextArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDataQualityJobDefinitionRequest {
    /// <p>The name of the data quality monitoring job definition to delete.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDeviceFleetRequest {
    /// <p>The name of the fleet to delete.</p>
    #[serde(rename = "DeviceFleetName")]
    pub device_fleet_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDomainRequest {
    /// <p>The domain ID.</p>
    #[serde(rename = "DomainId")]
    pub domain_id: String,
    /// <p>The retention policy for this domain, which specifies whether resources will be retained after the Domain is deleted. By default, all resources are retained (not automatically deleted). </p>
    #[serde(rename = "RetentionPolicy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retention_policy: Option<RetentionPolicy>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteEndpointConfigInput {
    /// <p>The name of the endpoint configuration that you want to delete.</p>
    #[serde(rename = "EndpointConfigName")]
    pub endpoint_config_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteEndpointInput {
    /// <p>The name of the endpoint that you want to delete.</p>
    #[serde(rename = "EndpointName")]
    pub endpoint_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteExperimentRequest {
    /// <p>The name of the experiment to delete.</p>
    #[serde(rename = "ExperimentName")]
    pub experiment_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteExperimentResponse {
    /// <p>The Amazon Resource Name (ARN) of the experiment that is being deleted.</p>
    #[serde(rename = "ExperimentArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFeatureGroupRequest {
    /// <p>The name of the <code>FeatureGroup</code> you want to delete. The name must be unique within an AWS Region in an AWS account. </p>
    #[serde(rename = "FeatureGroupName")]
    pub feature_group_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFlowDefinitionRequest {
    /// <p>The name of the flow definition you are deleting.</p>
    #[serde(rename = "FlowDefinitionName")]
    pub flow_definition_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteFlowDefinitionResponse {}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteHumanTaskUiRequest {
    /// <p>The name of the human task user interface (work task template) you want to delete.</p>
    #[serde(rename = "HumanTaskUiName")]
    pub human_task_ui_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteHumanTaskUiResponse {}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteImageRequest {
    /// <p>The name of the image to delete.</p>
    #[serde(rename = "ImageName")]
    pub image_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteImageResponse {}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteImageVersionRequest {
    /// <p>The name of the image.</p>
    #[serde(rename = "ImageName")]
    pub image_name: String,
    /// <p>The version to delete.</p>
    #[serde(rename = "Version")]
    pub version: i64,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteImageVersionResponse {}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteModelBiasJobDefinitionRequest {
    /// <p>The name of the model bias job definition to delete.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteModelExplainabilityJobDefinitionRequest {
    /// <p>The name of the model explainability job definition to delete.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteModelInput {
    /// <p>The name of the model to delete.</p>
    #[serde(rename = "ModelName")]
    pub model_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteModelPackageGroupInput {
    /// <p>The name of the model group to delete.</p>
    #[serde(rename = "ModelPackageGroupName")]
    pub model_package_group_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteModelPackageGroupPolicyInput {
    /// <p>The name of the model group for which to delete the policy.</p>
    #[serde(rename = "ModelPackageGroupName")]
    pub model_package_group_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteModelPackageInput {
    /// <p>The name of the model package. The name must have 1 to 63 characters. Valid characters are a-z, A-Z, 0-9, and - (hyphen).</p>
    #[serde(rename = "ModelPackageName")]
    pub model_package_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteModelQualityJobDefinitionRequest {
    /// <p>The name of the model quality monitoring job definition to delete.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteMonitoringScheduleRequest {
    /// <p>The name of the monitoring schedule to delete.</p>
    #[serde(rename = "MonitoringScheduleName")]
    pub monitoring_schedule_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteNotebookInstanceInput {
    /// <p>The name of the Amazon SageMaker notebook instance to delete.</p>
    #[serde(rename = "NotebookInstanceName")]
    pub notebook_instance_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteNotebookInstanceLifecycleConfigInput {
    /// <p>The name of the lifecycle configuration to delete.</p>
    #[serde(rename = "NotebookInstanceLifecycleConfigName")]
    pub notebook_instance_lifecycle_config_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeletePipelineRequest {
    /// <p>A unique, case-sensitive identifier that you provide to ensure the idempotency of the operation. An idempotent operation completes no more than one time.</p>
    #[serde(rename = "ClientRequestToken")]
    pub client_request_token: String,
    /// <p>The name of the pipeline to delete.</p>
    #[serde(rename = "PipelineName")]
    pub pipeline_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeletePipelineResponse {
    /// <p>The Amazon Resource Name (ARN) of the pipeline to delete.</p>
    #[serde(rename = "PipelineArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteProjectInput {
    /// <p>The name of the project to delete.</p>
    #[serde(rename = "ProjectName")]
    pub project_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTagsInput {
    /// <p>The Amazon Resource Name (ARN) of the resource whose tags you want to delete.</p>
    #[serde(rename = "ResourceArn")]
    pub resource_arn: String,
    /// <p>An array or one or more tag keys to delete.</p>
    #[serde(rename = "TagKeys")]
    pub tag_keys: Vec<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteTagsOutput {}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTrialComponentRequest {
    /// <p>The name of the component to delete.</p>
    #[serde(rename = "TrialComponentName")]
    pub trial_component_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteTrialComponentResponse {
    /// <p>The Amazon Resource Name (ARN) of the component is being deleted.</p>
    #[serde(rename = "TrialComponentArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTrialRequest {
    /// <p>The name of the trial to delete.</p>
    #[serde(rename = "TrialName")]
    pub trial_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteTrialResponse {
    /// <p>The Amazon Resource Name (ARN) of the trial that is being deleted.</p>
    #[serde(rename = "TrialArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteUserProfileRequest {
    /// <p>The domain ID.</p>
    #[serde(rename = "DomainId")]
    pub domain_id: String,
    /// <p>The user profile name.</p>
    #[serde(rename = "UserProfileName")]
    pub user_profile_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteWorkforceRequest {
    /// <p>The name of the workforce.</p>
    #[serde(rename = "WorkforceName")]
    pub workforce_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteWorkforceResponse {}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteWorkteamRequest {
    /// <p>The name of the work team to delete.</p>
    #[serde(rename = "WorkteamName")]
    pub workteam_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteWorkteamResponse {
    /// <p>Returns <code>true</code> if the work team was successfully deleted; otherwise, returns <code>false</code>.</p>
    #[serde(rename = "Success")]
    pub success: bool,
}

/// <p>Gets the Amazon EC2 Container Registry path of the docker image of the model that is hosted in this <a>ProductionVariant</a>.</p> <p>If you used the <code>registry/repository[:tag]</code> form to specify the image path of the primary container when you created the model hosted in this <code>ProductionVariant</code>, the path resolves to a path of the form <code>registry/repository[@digest]</code>. A digest is a hash value that identifies a specific version of an image. For information about Amazon ECR paths, see <a href="https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-pull-ecr-image.html">Pulling an Image</a> in the <i>Amazon ECR User Guide</i>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeployedImage {
    /// <p>The date and time when the image path for the model resolved to the <code>ResolvedImage</code> </p>
    #[serde(rename = "ResolutionTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resolution_time: Option<f64>,
    /// <p>The specific digest path of the image hosted in this <code>ProductionVariant</code>.</p>
    #[serde(rename = "ResolvedImage")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resolved_image: Option<String>,
    /// <p>The image path you specified when you created the model.</p>
    #[serde(rename = "SpecifiedImage")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub specified_image: Option<String>,
}

/// <p>Currently, the <code>DeploymentConfig</code> API is not supported.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeploymentConfig {
    /// <p><p/></p>
    #[serde(rename = "AutoRollbackConfiguration")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_rollback_configuration: Option<AutoRollbackConfig>,
    /// <p><p/></p>
    #[serde(rename = "BlueGreenUpdatePolicy")]
    pub blue_green_update_policy: BlueGreenUpdatePolicy,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeregisterDevicesRequest {
    /// <p>The name of the fleet the devices belong to.</p>
    #[serde(rename = "DeviceFleetName")]
    pub device_fleet_name: String,
    /// <p>The unique IDs of the devices.</p>
    #[serde(rename = "DeviceNames")]
    pub device_names: Vec<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeActionRequest {
    /// <p>The name of the action to describe.</p>
    #[serde(rename = "ActionName")]
    pub action_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeActionResponse {
    /// <p>The Amazon Resource Name (ARN) of the action.</p>
    #[serde(rename = "ActionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub action_arn: Option<String>,
    /// <p>The name of the action.</p>
    #[serde(rename = "ActionName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub action_name: Option<String>,
    /// <p>The type of the action.</p>
    #[serde(rename = "ActionType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub action_type: Option<String>,
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>When the action was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The description of the action.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>When the action was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    #[serde(rename = "MetadataProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_properties: Option<MetadataProperties>,
    /// <p>A list of the action's properties.</p>
    #[serde(rename = "Properties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub properties: Option<::std::collections::HashMap<String, String>>,
    /// <p>The source of the action.</p>
    #[serde(rename = "Source")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<ActionSource>,
    /// <p>The status of the action.</p>
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAlgorithmInput {
    /// <p>The name of the algorithm to describe.</p>
    #[serde(rename = "AlgorithmName")]
    pub algorithm_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeAlgorithmOutput {
    /// <p>The Amazon Resource Name (ARN) of the algorithm.</p>
    #[serde(rename = "AlgorithmArn")]
    pub algorithm_arn: String,
    /// <p>A brief summary about the algorithm.</p>
    #[serde(rename = "AlgorithmDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub algorithm_description: Option<String>,
    /// <p>The name of the algorithm being described.</p>
    #[serde(rename = "AlgorithmName")]
    pub algorithm_name: String,
    /// <p>The current status of the algorithm.</p>
    #[serde(rename = "AlgorithmStatus")]
    pub algorithm_status: String,
    /// <p>Details about the current status of the algorithm.</p>
    #[serde(rename = "AlgorithmStatusDetails")]
    pub algorithm_status_details: AlgorithmStatusDetails,
    /// <p>Whether the algorithm is certified to be listed in AWS Marketplace.</p>
    #[serde(rename = "CertifyForMarketplace")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub certify_for_marketplace: Option<bool>,
    /// <p>A timestamp specifying when the algorithm was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>Details about inference jobs that the algorithm runs.</p>
    #[serde(rename = "InferenceSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inference_specification: Option<InferenceSpecification>,
    /// <p>The product identifier of the algorithm.</p>
    #[serde(rename = "ProductId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub product_id: Option<String>,
    /// <p>Details about training jobs run by this algorithm.</p>
    #[serde(rename = "TrainingSpecification")]
    pub training_specification: TrainingSpecification,
    /// <p>Details about configurations for one or more training jobs that Amazon SageMaker runs to test the algorithm.</p>
    #[serde(rename = "ValidationSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub validation_specification: Option<AlgorithmValidationSpecification>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAppImageConfigRequest {
    /// <p>The name of the AppImageConfig to describe.</p>
    #[serde(rename = "AppImageConfigName")]
    pub app_image_config_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeAppImageConfigResponse {
    /// <p>The Amazon Resource Name (ARN) of the AppImageConfig.</p>
    #[serde(rename = "AppImageConfigArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_image_config_arn: Option<String>,
    /// <p>The name of the AppImageConfig.</p>
    #[serde(rename = "AppImageConfigName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_image_config_name: Option<String>,
    /// <p>When the AppImageConfig was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The configuration of a KernelGateway app.</p>
    #[serde(rename = "KernelGatewayImageConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kernel_gateway_image_config: Option<KernelGatewayImageConfig>,
    /// <p>When the AppImageConfig was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAppRequest {
    /// <p>The name of the app.</p>
    #[serde(rename = "AppName")]
    pub app_name: String,
    /// <p>The type of app.</p>
    #[serde(rename = "AppType")]
    pub app_type: String,
    /// <p>The domain ID.</p>
    #[serde(rename = "DomainId")]
    pub domain_id: String,
    /// <p>The user profile name.</p>
    #[serde(rename = "UserProfileName")]
    pub user_profile_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeAppResponse {
    /// <p>The Amazon Resource Name (ARN) of the app.</p>
    #[serde(rename = "AppArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_arn: Option<String>,
    /// <p>The name of the app.</p>
    #[serde(rename = "AppName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_name: Option<String>,
    /// <p>The type of app.</p>
    #[serde(rename = "AppType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_type: Option<String>,
    /// <p>The creation time.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The domain ID.</p>
    #[serde(rename = "DomainId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_id: Option<String>,
    /// <p>The failure reason.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The timestamp of the last health check.</p>
    #[serde(rename = "LastHealthCheckTimestamp")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_health_check_timestamp: Option<f64>,
    /// <p>The timestamp of the last user's activity.</p>
    #[serde(rename = "LastUserActivityTimestamp")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_user_activity_timestamp: Option<f64>,
    /// <p>The instance type and the Amazon Resource Name (ARN) of the SageMaker image created on the instance.</p>
    #[serde(rename = "ResourceSpec")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resource_spec: Option<ResourceSpec>,
    /// <p>The status.</p>
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    /// <p>The user profile name.</p>
    #[serde(rename = "UserProfileName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_profile_name: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeArtifactRequest {
    /// <p>The Amazon Resource Name (ARN) of the artifact to describe.</p>
    #[serde(rename = "ArtifactArn")]
    pub artifact_arn: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeArtifactResponse {
    /// <p>The Amazon Resource Name (ARN) of the artifact.</p>
    #[serde(rename = "ArtifactArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artifact_arn: Option<String>,
    /// <p>The name of the artifact.</p>
    #[serde(rename = "ArtifactName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artifact_name: Option<String>,
    /// <p>The type of the artifact.</p>
    #[serde(rename = "ArtifactType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artifact_type: Option<String>,
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>When the artifact was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>When the artifact was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    #[serde(rename = "MetadataProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_properties: Option<MetadataProperties>,
    /// <p>A list of the artifact's properties.</p>
    #[serde(rename = "Properties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub properties: Option<::std::collections::HashMap<String, String>>,
    /// <p>The source of the artifact.</p>
    #[serde(rename = "Source")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<ArtifactSource>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAutoMLJobRequest {
    /// <p>Request information about a job using that job's unique name.</p>
    #[serde(rename = "AutoMLJobName")]
    pub auto_ml_job_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeAutoMLJobResponse {
    /// <p>Returns the job's ARN.</p>
    #[serde(rename = "AutoMLJobArn")]
    pub auto_ml_job_arn: String,
    /// <p>Returns information on the job's artifacts found in AutoMLJobArtifacts.</p>
    #[serde(rename = "AutoMLJobArtifacts")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_ml_job_artifacts: Option<AutoMLJobArtifacts>,
    /// <p>Returns the job's config.</p>
    #[serde(rename = "AutoMLJobConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_ml_job_config: Option<AutoMLJobConfig>,
    /// <p>Returns the name of a job.</p>
    #[serde(rename = "AutoMLJobName")]
    pub auto_ml_job_name: String,
    /// <p>Returns the job's objective.</p>
    #[serde(rename = "AutoMLJobObjective")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_ml_job_objective: Option<AutoMLJobObjective>,
    /// <p>Returns the job's AutoMLJobSecondaryStatus.</p>
    #[serde(rename = "AutoMLJobSecondaryStatus")]
    pub auto_ml_job_secondary_status: String,
    /// <p>Returns the job's AutoMLJobStatus.</p>
    #[serde(rename = "AutoMLJobStatus")]
    pub auto_ml_job_status: String,
    /// <p>Returns the job's BestCandidate.</p>
    #[serde(rename = "BestCandidate")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub best_candidate: Option<AutoMLCandidate>,
    /// <p>Returns the job's creation time.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>Returns the job's end time.</p>
    #[serde(rename = "EndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub end_time: Option<f64>,
    /// <p>Returns the job's FailureReason.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>Returns the job's output from GenerateCandidateDefinitionsOnly.</p>
    #[serde(rename = "GenerateCandidateDefinitionsOnly")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub generate_candidate_definitions_only: Option<bool>,
    /// <p>Returns the job's input data config.</p>
    #[serde(rename = "InputDataConfig")]
    pub input_data_config: Vec<AutoMLChannel>,
    /// <p>Returns the job's last modified time.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
    /// <p>Returns the job's output data config.</p>
    #[serde(rename = "OutputDataConfig")]
    pub output_data_config: AutoMLOutputDataConfig,
    /// <p>Returns the job's problem type.</p>
    #[serde(rename = "ProblemType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub problem_type: Option<String>,
    /// <p>This contains ProblemType, AutoMLJobObjective and CompletionCriteria. They're auto-inferred values, if not provided by you. If you do provide them, then they'll be the same as provided.</p>
    #[serde(rename = "ResolvedAttributes")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resolved_attributes: Option<ResolvedAttributes>,
    /// <p>The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM) role that has read permission to the input data location and write permission to the output data location in Amazon S3.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCodeRepositoryInput {
    /// <p>The name of the Git repository to describe.</p>
    #[serde(rename = "CodeRepositoryName")]
    pub code_repository_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeCodeRepositoryOutput {
    /// <p>The Amazon Resource Name (ARN) of the Git repository.</p>
    #[serde(rename = "CodeRepositoryArn")]
    pub code_repository_arn: String,
    /// <p>The name of the Git repository.</p>
    #[serde(rename = "CodeRepositoryName")]
    pub code_repository_name: String,
    /// <p>The date and time that the repository was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>Configuration details about the repository, including the URL where the repository is located, the default branch, and the Amazon Resource Name (ARN) of the AWS Secrets Manager secret that contains the credentials used to access the repository.</p>
    #[serde(rename = "GitConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub git_config: Option<GitConfig>,
    /// <p>The date and time that the repository was last changed.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCompilationJobRequest {
    /// <p>The name of the model compilation job that you want information about.</p>
    #[serde(rename = "CompilationJobName")]
    pub compilation_job_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeCompilationJobResponse {
    /// <p>The time when the model compilation job on a compilation job instance ended. For a successful or stopped job, this is when the job's model artifacts have finished uploading. For a failed job, this is when Amazon SageMaker detected that the job failed. </p>
    #[serde(rename = "CompilationEndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub compilation_end_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker assumes to perform the model compilation job.</p>
    #[serde(rename = "CompilationJobArn")]
    pub compilation_job_arn: String,
    /// <p>The name of the model compilation job.</p>
    #[serde(rename = "CompilationJobName")]
    pub compilation_job_name: String,
    /// <p>The status of the model compilation job.</p>
    #[serde(rename = "CompilationJobStatus")]
    pub compilation_job_status: String,
    /// <p>The time when the model compilation job started the <code>CompilationJob</code> instances. </p> <p>You are billed for the time between this timestamp and the timestamp in the <a>DescribeCompilationJobResponse$CompilationEndTime</a> field. In Amazon CloudWatch Logs, the start time might be later than this time. That's because it takes time to download the compilation job, which depends on the size of the compilation job container. </p>
    #[serde(rename = "CompilationStartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub compilation_start_time: Option<f64>,
    /// <p>The time that the model compilation job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>If a model compilation job failed, the reason it failed. </p>
    #[serde(rename = "FailureReason")]
    pub failure_reason: String,
    /// <p>Information about the location in Amazon S3 of the input model artifacts, the name and shape of the expected data inputs, and the framework in which the model was trained.</p>
    #[serde(rename = "InputConfig")]
    pub input_config: InputConfig,
    /// <p>The time that the status of the model compilation job was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
    /// <p>Information about the location in Amazon S3 that has been configured for storing the model artifacts used in the compilation job.</p>
    #[serde(rename = "ModelArtifacts")]
    pub model_artifacts: ModelArtifacts,
    /// <p>Provides a BLAKE2 hash value that identifies the compiled model artifacts in Amazon S3.</p>
    #[serde(rename = "ModelDigests")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_digests: Option<ModelDigests>,
    /// <p>Information about the output location for the compiled model and the target device that the model runs on.</p>
    #[serde(rename = "OutputConfig")]
    pub output_config: OutputConfig,
    /// <p>The Amazon Resource Name (ARN) of the model compilation job.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    /// <p>Specifies a limit to how long a model compilation job can run. When the job reaches the time limit, Amazon SageMaker ends the compilation job. Use this API to cap model training costs.</p>
    #[serde(rename = "StoppingCondition")]
    pub stopping_condition: StoppingCondition,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeContextRequest {
    /// <p>The name of the context to describe.</p>
    #[serde(rename = "ContextName")]
    pub context_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeContextResponse {
    /// <p>The Amazon Resource Name (ARN) of the context.</p>
    #[serde(rename = "ContextArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context_arn: Option<String>,
    /// <p>The name of the context.</p>
    #[serde(rename = "ContextName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context_name: Option<String>,
    /// <p>The type of the context.</p>
    #[serde(rename = "ContextType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context_type: Option<String>,
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>When the context was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The description of the context.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>When the context was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>A list of the context's properties.</p>
    #[serde(rename = "Properties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub properties: Option<::std::collections::HashMap<String, String>>,
    /// <p>The source of the context.</p>
    #[serde(rename = "Source")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<ContextSource>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDataQualityJobDefinitionRequest {
    /// <p>The name of the data quality monitoring job definition to describe.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDataQualityJobDefinitionResponse {
    /// <p>The time that the data quality monitoring job definition was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>Information about the container that runs the data quality monitoring job.</p>
    #[serde(rename = "DataQualityAppSpecification")]
    pub data_quality_app_specification: DataQualityAppSpecification,
    /// <p>The constraints and baselines for the data quality monitoring job definition.</p>
    #[serde(rename = "DataQualityBaselineConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data_quality_baseline_config: Option<DataQualityBaselineConfig>,
    /// <p>The list of inputs for the data quality monitoring job. Currently endpoints are supported.</p>
    #[serde(rename = "DataQualityJobInput")]
    pub data_quality_job_input: DataQualityJobInput,
    #[serde(rename = "DataQualityJobOutputConfig")]
    pub data_quality_job_output_config: MonitoringOutputConfig,
    /// <p>The Amazon Resource Name (ARN) of the data quality monitoring job definition.</p>
    #[serde(rename = "JobDefinitionArn")]
    pub job_definition_arn: String,
    /// <p>The name of the data quality monitoring job definition.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
    #[serde(rename = "JobResources")]
    pub job_resources: MonitoringResources,
    /// <p>The networking configuration for the data quality monitoring job.</p>
    #[serde(rename = "NetworkConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub network_config: Option<MonitoringNetworkConfig>,
    /// <p>The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume to perform tasks on your behalf.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    #[serde(rename = "StoppingCondition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopping_condition: Option<MonitoringStoppingCondition>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDeviceFleetRequest {
    /// <p>The name of the fleet.</p>
    #[serde(rename = "DeviceFleetName")]
    pub device_fleet_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDeviceFleetResponse {
    /// <p>Timestamp of when the device fleet was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>A description of the fleet.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The The Amazon Resource Name (ARN) of the fleet.</p>
    #[serde(rename = "DeviceFleetArn")]
    pub device_fleet_arn: String,
    /// <p>The name of the fleet.</p>
    #[serde(rename = "DeviceFleetName")]
    pub device_fleet_name: String,
    /// <p>The Amazon Resource Name (ARN) alias created in AWS Internet of Things (IoT).</p>
    #[serde(rename = "IotRoleAlias")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub iot_role_alias: Option<String>,
    /// <p>Timestamp of when the device fleet was last updated.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
    /// <p>The output configuration for storing sampled data.</p>
    #[serde(rename = "OutputConfig")]
    pub output_config: EdgeOutputConfig,
    /// <p>The Amazon Resource Name (ARN) that has access to AWS Internet of Things (IoT).</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDeviceRequest {
    /// <p>The name of the fleet the devices belong to.</p>
    #[serde(rename = "DeviceFleetName")]
    pub device_fleet_name: String,
    /// <p>The unique ID of the device.</p>
    #[serde(rename = "DeviceName")]
    pub device_name: String,
    /// <p>Next token of device description.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDeviceResponse {
    /// <p>A description of the device.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the device.</p>
    #[serde(rename = "DeviceArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub device_arn: Option<String>,
    /// <p>The name of the fleet the device belongs to.</p>
    #[serde(rename = "DeviceFleetName")]
    pub device_fleet_name: String,
    /// <p>The unique identifier of the device.</p>
    #[serde(rename = "DeviceName")]
    pub device_name: String,
    /// <p>The AWS Internet of Things (IoT) object thing name associated with the device.</p>
    #[serde(rename = "IotThingName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub iot_thing_name: Option<String>,
    /// <p>The last heartbeat received from the device.</p>
    #[serde(rename = "LatestHeartbeat")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latest_heartbeat: Option<f64>,
    /// <p>The maximum number of models.</p>
    #[serde(rename = "MaxModels")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_models: Option<i64>,
    /// <p>Models on the device.</p>
    #[serde(rename = "Models")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub models: Option<Vec<EdgeModel>>,
    /// <p>The response from the last list when returning a list large enough to need tokening.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The timestamp of the last registration or de-reregistration.</p>
    #[serde(rename = "RegistrationTime")]
    pub registration_time: f64,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDomainRequest {
    /// <p>The domain ID.</p>
    #[serde(rename = "DomainId")]
    pub domain_id: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDomainResponse {
    /// <p><p>Specifies the VPC used for non-EFS traffic. The default value is <code>PublicInternetOnly</code>.</p> <ul> <li> <p> <code>PublicInternetOnly</code> - Non-EFS traffic is through a VPC managed by Amazon SageMaker, which allows direct internet access</p> </li> <li> <p> <code>VpcOnly</code> - All Studio traffic is through the specified VPC and subnets</p> </li> </ul></p>
    #[serde(rename = "AppNetworkAccessType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_network_access_type: Option<String>,
    /// <p>The domain's authentication mode.</p>
    #[serde(rename = "AuthMode")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auth_mode: Option<String>,
    /// <p>The creation time.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>Settings which are applied to all UserProfiles in this domain, if settings are not explicitly specified in a given UserProfile. </p>
    #[serde(rename = "DefaultUserSettings")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_user_settings: Option<UserSettings>,
    /// <p>The domain's Amazon Resource Name (ARN).</p>
    #[serde(rename = "DomainArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_arn: Option<String>,
    /// <p>The domain ID.</p>
    #[serde(rename = "DomainId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_id: Option<String>,
    /// <p>The domain name.</p>
    #[serde(rename = "DomainName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_name: Option<String>,
    /// <p>The failure reason.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The ID of the Amazon Elastic File System (EFS) managed by this Domain.</p>
    #[serde(rename = "HomeEfsFileSystemId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub home_efs_file_system_id: Option<String>,
    /// <p>The AWS KMS customer managed CMK used to encrypt the EFS volume attached to the domain.</p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>The last modified time.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The SSO managed application instance ID.</p>
    #[serde(rename = "SingleSignOnManagedApplicationInstanceId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub single_sign_on_managed_application_instance_id: Option<String>,
    /// <p>The status.</p>
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    /// <p>The VPC subnets that Studio uses for communication.</p>
    #[serde(rename = "SubnetIds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subnet_ids: Option<Vec<String>>,
    /// <p>The domain's URL.</p>
    #[serde(rename = "Url")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    /// <p>The ID of the Amazon Virtual Private Cloud (VPC) that Studio uses for communication.</p>
    #[serde(rename = "VpcId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpc_id: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeEdgePackagingJobRequest {
    /// <p>The name of the edge packaging job.</p>
    #[serde(rename = "EdgePackagingJobName")]
    pub edge_packaging_job_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeEdgePackagingJobResponse {
    /// <p>The name of the SageMaker Neo compilation job that is used to locate model artifacts that are being packaged.</p>
    #[serde(rename = "CompilationJobName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub compilation_job_name: Option<String>,
    /// <p>The timestamp of when the packaging job was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the edge packaging job.</p>
    #[serde(rename = "EdgePackagingJobArn")]
    pub edge_packaging_job_arn: String,
    /// <p>The name of the edge packaging job.</p>
    #[serde(rename = "EdgePackagingJobName")]
    pub edge_packaging_job_name: String,
    /// <p>The current status of the packaging job.</p>
    #[serde(rename = "EdgePackagingJobStatus")]
    pub edge_packaging_job_status: String,
    /// <p>Returns a message describing the job status and error messages.</p>
    #[serde(rename = "EdgePackagingJobStatusMessage")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edge_packaging_job_status_message: Option<String>,
    /// <p>The timestamp of when the job was last updated.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The Amazon Simple Storage (S3) URI where model artifacts ares stored.</p>
    #[serde(rename = "ModelArtifact")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_artifact: Option<String>,
    /// <p>The name of the model.</p>
    #[serde(rename = "ModelName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_name: Option<String>,
    /// <p>The signature document of files in the model artifact.</p>
    #[serde(rename = "ModelSignature")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_signature: Option<String>,
    /// <p>The version of the model.</p>
    #[serde(rename = "ModelVersion")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_version: Option<String>,
    /// <p>The output configuration for the edge packaging job.</p>
    #[serde(rename = "OutputConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_config: Option<EdgeOutputConfig>,
    /// <p>The CMK to use when encrypting the EBS volume the job run on.</p>
    #[serde(rename = "ResourceKey")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resource_key: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of an IAM role that enables Amazon SageMaker to download and upload the model, and to contact Neo.</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeEndpointConfigInput {
    /// <p>The name of the endpoint configuration.</p>
    #[serde(rename = "EndpointConfigName")]
    pub endpoint_config_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeEndpointConfigOutput {
    /// <p>A timestamp that shows when the endpoint configuration was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    #[serde(rename = "DataCaptureConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data_capture_config: Option<DataCaptureConfig>,
    /// <p>The Amazon Resource Name (ARN) of the endpoint configuration.</p>
    #[serde(rename = "EndpointConfigArn")]
    pub endpoint_config_arn: String,
    /// <p>Name of the Amazon SageMaker endpoint configuration.</p>
    #[serde(rename = "EndpointConfigName")]
    pub endpoint_config_name: String,
    /// <p>AWS KMS key ID Amazon SageMaker uses to encrypt data when storing it on the ML storage volume attached to the instance.</p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>An array of <code>ProductionVariant</code> objects, one for each model that you want to host at this endpoint.</p>
    #[serde(rename = "ProductionVariants")]
    pub production_variants: Vec<ProductionVariant>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeEndpointInput {
    /// <p>The name of the endpoint.</p>
    #[serde(rename = "EndpointName")]
    pub endpoint_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeEndpointOutput {
    /// <p>A timestamp that shows when the endpoint was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    #[serde(rename = "DataCaptureConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data_capture_config: Option<DataCaptureConfigSummary>,
    /// <p>The Amazon Resource Name (ARN) of the endpoint.</p>
    #[serde(rename = "EndpointArn")]
    pub endpoint_arn: String,
    /// <p>The name of the endpoint configuration associated with this endpoint.</p>
    #[serde(rename = "EndpointConfigName")]
    pub endpoint_config_name: String,
    /// <p>Name of the endpoint.</p>
    #[serde(rename = "EndpointName")]
    pub endpoint_name: String,
    /// <p><p>The status of the endpoint.</p> <ul> <li> <p> <code>OutOfService</code>: Endpoint is not available to take incoming requests.</p> </li> <li> <p> <code>Creating</code>: <a>CreateEndpoint</a> is executing.</p> </li> <li> <p> <code>Updating</code>: <a>UpdateEndpoint</a> or <a>UpdateEndpointWeightsAndCapacities</a> is executing.</p> </li> <li> <p> <code>SystemUpdating</code>: Endpoint is undergoing maintenance and cannot be updated or deleted or re-scaled until it has completed. This maintenance operation does not change any customer-specified values such as VPC config, KMS encryption, model, instance type, or instance count.</p> </li> <li> <p> <code>RollingBack</code>: Endpoint fails to scale up or down or change its variant weight and is in the process of rolling back to its previous configuration. Once the rollback completes, endpoint returns to an <code>InService</code> status. This transitional status only applies to an endpoint that has autoscaling enabled and is undergoing variant weight or capacity changes as part of an <a>UpdateEndpointWeightsAndCapacities</a> call or when the <a>UpdateEndpointWeightsAndCapacities</a> operation is called explicitly.</p> </li> <li> <p> <code>InService</code>: Endpoint is available to process incoming requests.</p> </li> <li> <p> <code>Deleting</code>: <a>DeleteEndpoint</a> is executing.</p> </li> <li> <p> <code>Failed</code>: Endpoint could not be created, updated, or re-scaled. Use <a>DescribeEndpointOutput$FailureReason</a> for information about the failure. <a>DeleteEndpoint</a> is the only operation that can be performed on a failed endpoint.</p> </li> </ul></p>
    #[serde(rename = "EndpointStatus")]
    pub endpoint_status: String,
    /// <p>If the status of the endpoint is <code>Failed</code>, the reason why it failed. </p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The most recent deployment configuration for the endpoint.</p>
    #[serde(rename = "LastDeploymentConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_deployment_config: Option<DeploymentConfig>,
    /// <p>A timestamp that shows when the endpoint was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
    /// <p> An array of <a>ProductionVariantSummary</a> objects, one for each model hosted behind this endpoint. </p>
    #[serde(rename = "ProductionVariants")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub production_variants: Option<Vec<ProductionVariantSummary>>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeExperimentRequest {
    /// <p>The name of the experiment to describe.</p>
    #[serde(rename = "ExperimentName")]
    pub experiment_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeExperimentResponse {
    /// <p>Who created the experiment.</p>
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>When the experiment was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The description of the experiment.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The name of the experiment as displayed. If <code>DisplayName</code> isn't specified, <code>ExperimentName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the experiment.</p>
    #[serde(rename = "ExperimentArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_arn: Option<String>,
    /// <p>The name of the experiment.</p>
    #[serde(rename = "ExperimentName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_name: Option<String>,
    /// <p>Who last modified the experiment.</p>
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>When the experiment was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The ARN of the source and, optionally, the type.</p>
    #[serde(rename = "Source")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<ExperimentSource>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeFeatureGroupRequest {
    /// <p>The name of the <code>FeatureGroup</code> you want described. </p>
    #[serde(rename = "FeatureGroupName")]
    pub feature_group_name: String,
    /// <p>A token to resume pagination of the list of <code>Features</code> (<code>FeatureDefinitions</code>). 2,500 <code>Features</code> are returned by default.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeFeatureGroupResponse {
    /// <p>A timestamp indicating when SageMaker created the <code>FeatureGroup</code>.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>A free form description of the feature group.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The name of the feature that stores the <code>EventTime</code> of a Record in a <code>FeatureGroup</code>.</p> <p> An <code>EventTime</code> is a point in time when a new event occurs that corresponds to the creation or update of a <code>Record</code> in a <code>FeatureGroup</code>. All <code>Records</code> in the <code>FeatureGroup</code> have a corresponding <code>EventTime</code>.</p>
    #[serde(rename = "EventTimeFeatureName")]
    pub event_time_feature_name: String,
    /// <p><p>The reason that the <code>FeatureGroup</code> failed to be replicated in the <code>OfflineStore</code>. This is failure can occur because:</p> <ul> <li> <p>The <code>FeatureGroup</code> could not be created in the <code>OfflineStore</code>.</p> </li> <li> <p>The <code>FeatureGroup</code> could not be deleted from the <code>OfflineStore</code>.</p> </li> </ul></p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>A list of the <code>Features</code> in the <code>FeatureGroup</code>. Each feature is defined by a <code>FeatureName</code> and <code>FeatureType</code>.</p>
    #[serde(rename = "FeatureDefinitions")]
    pub feature_definitions: Vec<FeatureDefinition>,
    /// <p>The Amazon Resource Name (ARN) of the <code>FeatureGroup</code>. </p>
    #[serde(rename = "FeatureGroupArn")]
    pub feature_group_arn: String,
    /// <p>he name of the <code>FeatureGroup</code>.</p>
    #[serde(rename = "FeatureGroupName")]
    pub feature_group_name: String,
    /// <p>The status of the feature group.</p>
    #[serde(rename = "FeatureGroupStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub feature_group_status: Option<String>,
    /// <p>A token to resume pagination of the list of <code>Features</code> (<code>FeatureDefinitions</code>).</p>
    #[serde(rename = "NextToken")]
    pub next_token: String,
    /// <p>The configuration of the <code>OfflineStore</code>, inducing the S3 location of the <code>OfflineStore</code>, AWS Glue or AWS Hive data catalogue configurations, and the security configuration.</p>
    #[serde(rename = "OfflineStoreConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offline_store_config: Option<OfflineStoreConfig>,
    /// <p>The status of the <code>OfflineStore</code>. Notifies you if replicating data into the <code>OfflineStore</code> has failed. Returns either: <code>Active</code> or <code>Blocked</code> </p>
    #[serde(rename = "OfflineStoreStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offline_store_status: Option<OfflineStoreStatus>,
    /// <p>The configuration for the <code>OnlineStore</code>.</p>
    #[serde(rename = "OnlineStoreConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub online_store_config: Option<OnlineStoreConfig>,
    /// <p>The name of the <code>Feature</code> used for <code>RecordIdentifier</code>, whose value uniquely identifies a record stored in the feature store.</p>
    #[serde(rename = "RecordIdentifierFeatureName")]
    pub record_identifier_feature_name: String,
    /// <p>The Amazon Resource Name (ARN) of the IAM execution role used to persist data into the <code>OfflineStore</code> if an <code>OfflineStoreConfig</code> is provided.</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeFlowDefinitionRequest {
    /// <p>The name of the flow definition.</p>
    #[serde(rename = "FlowDefinitionName")]
    pub flow_definition_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeFlowDefinitionResponse {
    /// <p>The timestamp when the flow definition was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The reason your flow definition failed.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the flow defintion.</p>
    #[serde(rename = "FlowDefinitionArn")]
    pub flow_definition_arn: String,
    /// <p>The Amazon Resource Name (ARN) of the flow definition.</p>
    #[serde(rename = "FlowDefinitionName")]
    pub flow_definition_name: String,
    /// <p>The status of the flow definition. Valid values are listed below.</p>
    #[serde(rename = "FlowDefinitionStatus")]
    pub flow_definition_status: String,
    /// <p>An object containing information about what triggers a human review workflow.</p>
    #[serde(rename = "HumanLoopActivationConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub human_loop_activation_config: Option<HumanLoopActivationConfig>,
    /// <p>An object containing information about who works on the task, the workforce task price, and other task details.</p>
    #[serde(rename = "HumanLoopConfig")]
    pub human_loop_config: HumanLoopConfig,
    /// <p>Container for configuring the source of human task requests. Used to specify if Amazon Rekognition or Amazon Textract is used as an integration source.</p>
    #[serde(rename = "HumanLoopRequestSource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub human_loop_request_source: Option<HumanLoopRequestSource>,
    /// <p>An object containing information about the output file.</p>
    #[serde(rename = "OutputConfig")]
    pub output_config: FlowDefinitionOutputConfig,
    /// <p>The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM) execution role for the flow definition.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeHumanTaskUiRequest {
    /// <p>The name of the human task user interface (worker task template) you want information about.</p>
    #[serde(rename = "HumanTaskUiName")]
    pub human_task_ui_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeHumanTaskUiResponse {
    /// <p>The timestamp when the human task user interface was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The Amazon Resource Name (ARN) of the human task user interface (worker task template).</p>
    #[serde(rename = "HumanTaskUiArn")]
    pub human_task_ui_arn: String,
    /// <p>The name of the human task user interface (worker task template).</p>
    #[serde(rename = "HumanTaskUiName")]
    pub human_task_ui_name: String,
    /// <p>The status of the human task user interface (worker task template). Valid values are listed below.</p>
    #[serde(rename = "HumanTaskUiStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub human_task_ui_status: Option<String>,
    #[serde(rename = "UiTemplate")]
    pub ui_template: UiTemplateInfo,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeHyperParameterTuningJobRequest {
    /// <p>The name of the tuning job.</p>
    #[serde(rename = "HyperParameterTuningJobName")]
    pub hyper_parameter_tuning_job_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeHyperParameterTuningJobResponse {
    /// <p>A <a>TrainingJobSummary</a> object that describes the training job that completed with the best current <a>HyperParameterTuningJobObjective</a>.</p>
    #[serde(rename = "BestTrainingJob")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub best_training_job: Option<HyperParameterTrainingJobSummary>,
    /// <p>The date and time that the tuning job started.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>If the tuning job failed, the reason it failed.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The date and time that the tuning job ended.</p>
    #[serde(rename = "HyperParameterTuningEndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hyper_parameter_tuning_end_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the tuning job.</p>
    #[serde(rename = "HyperParameterTuningJobArn")]
    pub hyper_parameter_tuning_job_arn: String,
    /// <p>The <a>HyperParameterTuningJobConfig</a> object that specifies the configuration of the tuning job.</p>
    #[serde(rename = "HyperParameterTuningJobConfig")]
    pub hyper_parameter_tuning_job_config: HyperParameterTuningJobConfig,
    /// <p>The name of the tuning job.</p>
    #[serde(rename = "HyperParameterTuningJobName")]
    pub hyper_parameter_tuning_job_name: String,
    /// <p>The status of the tuning job: InProgress, Completed, Failed, Stopping, or Stopped.</p>
    #[serde(rename = "HyperParameterTuningJobStatus")]
    pub hyper_parameter_tuning_job_status: String,
    /// <p>The date and time that the status of the tuning job was modified. </p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The <a>ObjectiveStatusCounters</a> object that specifies the number of training jobs, categorized by the status of their final objective metric, that this tuning job launched.</p>
    #[serde(rename = "ObjectiveStatusCounters")]
    pub objective_status_counters: ObjectiveStatusCounters,
    /// <p>If the hyperparameter tuning job is an warm start tuning job with a <code>WarmStartType</code> of <code>IDENTICAL_DATA_AND_ALGORITHM</code>, this is the <a>TrainingJobSummary</a> for the training job with the best objective metric value of all training jobs launched by this tuning job and all parent jobs specified for the warm start tuning job.</p>
    #[serde(rename = "OverallBestTrainingJob")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub overall_best_training_job: Option<HyperParameterTrainingJobSummary>,
    /// <p>The <a>HyperParameterTrainingJobDefinition</a> object that specifies the definition of the training jobs that this tuning job launches.</p>
    #[serde(rename = "TrainingJobDefinition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_job_definition: Option<HyperParameterTrainingJobDefinition>,
    /// <p>A list of the <a>HyperParameterTrainingJobDefinition</a> objects launched for this tuning job.</p>
    #[serde(rename = "TrainingJobDefinitions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_job_definitions: Option<Vec<HyperParameterTrainingJobDefinition>>,
    /// <p>The <a>TrainingJobStatusCounters</a> object that specifies the number of training jobs, categorized by status, that this tuning job launched.</p>
    #[serde(rename = "TrainingJobStatusCounters")]
    pub training_job_status_counters: TrainingJobStatusCounters,
    /// <p>The configuration for starting the hyperparameter parameter tuning job using one or more previous 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.</p>
    #[serde(rename = "WarmStartConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub warm_start_config: Option<HyperParameterTuningJobWarmStartConfig>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeImageRequest {
    /// <p>The name of the image to describe.</p>
    #[serde(rename = "ImageName")]
    pub image_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeImageResponse {
    /// <p>When the image was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The description of the image.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The name of the image as displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>When a create, update, or delete operation fails, the reason for the failure.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the image.</p>
    #[serde(rename = "ImageArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_arn: Option<String>,
    /// <p>The name of the image.</p>
    #[serde(rename = "ImageName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_name: Option<String>,
    /// <p>The status of the image.</p>
    #[serde(rename = "ImageStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_status: Option<String>,
    /// <p>When the image was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the IAM role that enables Amazon SageMaker to perform tasks on your behalf.</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeImageVersionRequest {
    /// <p>The name of the image.</p>
    #[serde(rename = "ImageName")]
    pub image_name: String,
    /// <p>The version of the image. If not specified, the latest version is described.</p>
    #[serde(rename = "Version")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub version: Option<i64>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeImageVersionResponse {
    /// <p>The registry path of the container image on which this image version is based.</p>
    #[serde(rename = "BaseImage")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub base_image: Option<String>,
    /// <p>The registry path of the container image that contains this image version.</p>
    #[serde(rename = "ContainerImage")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_image: Option<String>,
    /// <p>When the version was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>When a create or delete operation fails, the reason for the failure.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the image the version is based on.</p>
    #[serde(rename = "ImageArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_arn: Option<String>,
    /// <p>The ARN of the version.</p>
    #[serde(rename = "ImageVersionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_version_arn: Option<String>,
    /// <p>The status of the version.</p>
    #[serde(rename = "ImageVersionStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_version_status: Option<String>,
    /// <p>When the version was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The version number.</p>
    #[serde(rename = "Version")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub version: Option<i64>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeLabelingJobRequest {
    /// <p>The name of the labeling job to return information for.</p>
    #[serde(rename = "LabelingJobName")]
    pub labeling_job_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeLabelingJobResponse {
    /// <p>The date and time that the labeling job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>If the job failed, the reason that it failed. </p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>Configuration information required for human workers to complete a labeling task.</p>
    #[serde(rename = "HumanTaskConfig")]
    pub human_task_config: HumanTaskConfig,
    /// <p>Input configuration information for the labeling job, such as the Amazon S3 location of the data objects and the location of the manifest file that describes the data objects.</p>
    #[serde(rename = "InputConfig")]
    pub input_config: LabelingJobInputConfig,
    /// <p>A unique identifier for work done as part of a labeling job.</p>
    #[serde(rename = "JobReferenceCode")]
    pub job_reference_code: String,
    /// <p>The attribute used as the label in the output manifest file.</p>
    #[serde(rename = "LabelAttributeName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub label_attribute_name: Option<String>,
    /// <p>The S3 location of the JSON file that defines the categories used to label data objects. Please note the following label-category limits:</p> <ul> <li> <p>Semantic segmentation labeling jobs using automated labeling: 20 labels</p> </li> <li> <p>Box bounding labeling jobs (all): 10 labels</p> </li> </ul> <p>The file is a JSON structure in the following format:</p> <p> <code>{</code> </p> <p> <code> "document-version": "2018-11-28"</code> </p> <p> <code> "labels": [</code> </p> <p> <code> {</code> </p> <p> <code> "label": "<i>label 1</i>"</code> </p> <p> <code> },</code> </p> <p> <code> {</code> </p> <p> <code> "label": "<i>label 2</i>"</code> </p> <p> <code> },</code> </p> <p> <code> ...</code> </p> <p> <code> {</code> </p> <p> <code> "label": "<i>label n</i>"</code> </p> <p> <code> }</code> </p> <p> <code> ]</code> </p> <p> <code>}</code> </p>
    #[serde(rename = "LabelCategoryConfigS3Uri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub label_category_config_s3_uri: Option<String>,
    /// <p>Provides a breakdown of the number of data objects labeled by humans, the number of objects labeled by machine, the number of objects than couldn't be labeled, and the total number of objects labeled. </p>
    #[serde(rename = "LabelCounters")]
    pub label_counters: LabelCounters,
    /// <p>Configuration information for automated data labeling.</p>
    #[serde(rename = "LabelingJobAlgorithmsConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub labeling_job_algorithms_config: Option<LabelingJobAlgorithmsConfig>,
    /// <p>The Amazon Resource Name (ARN) of the labeling job.</p>
    #[serde(rename = "LabelingJobArn")]
    pub labeling_job_arn: String,
    /// <p>The name assigned to the labeling job when it was created.</p>
    #[serde(rename = "LabelingJobName")]
    pub labeling_job_name: String,
    /// <p>The location of the output produced by the labeling job.</p>
    #[serde(rename = "LabelingJobOutput")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub labeling_job_output: Option<LabelingJobOutput>,
    /// <p>The processing status of the labeling job. </p>
    #[serde(rename = "LabelingJobStatus")]
    pub labeling_job_status: String,
    /// <p>The date and time that the labeling job was last updated.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
    /// <p>The location of the job's output data and the AWS Key Management Service key ID for the key used to encrypt the output data, if any.</p>
    #[serde(rename = "OutputConfig")]
    pub output_config: LabelingJobOutputConfig,
    /// <p>The Amazon Resource Name (ARN) that Amazon SageMaker assumes to perform tasks on your behalf during data labeling.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    /// <p>A set of conditions for stopping a labeling job. If any of the conditions are met, the job is automatically stopped.</p>
    #[serde(rename = "StoppingConditions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopping_conditions: Option<LabelingJobStoppingConditions>,
    /// <p>An array of key-value pairs. You can use tags to categorize your AWS resources in different ways, for example, by purpose, owner, or environment. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS Resources</a>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeModelBiasJobDefinitionRequest {
    /// <p>The name of the model bias job definition. The name must be unique within an AWS Region in the AWS account.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeModelBiasJobDefinitionResponse {
    /// <p>The time at which the model bias job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The Amazon Resource Name (ARN) of the model bias job.</p>
    #[serde(rename = "JobDefinitionArn")]
    pub job_definition_arn: String,
    /// <p>The name of the bias job definition. The name must be unique within an AWS Region in the AWS account.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
    #[serde(rename = "JobResources")]
    pub job_resources: MonitoringResources,
    /// <p>Configures the model bias job to run a specified Docker container image.</p>
    #[serde(rename = "ModelBiasAppSpecification")]
    pub model_bias_app_specification: ModelBiasAppSpecification,
    /// <p>The baseline configuration for a model bias job.</p>
    #[serde(rename = "ModelBiasBaselineConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_bias_baseline_config: Option<ModelBiasBaselineConfig>,
    /// <p>Inputs for the model bias job.</p>
    #[serde(rename = "ModelBiasJobInput")]
    pub model_bias_job_input: ModelBiasJobInput,
    #[serde(rename = "ModelBiasJobOutputConfig")]
    pub model_bias_job_output_config: MonitoringOutputConfig,
    /// <p>Networking options for a model bias job.</p>
    #[serde(rename = "NetworkConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub network_config: Option<MonitoringNetworkConfig>,
    /// <p>The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM) role that has read permission to the input data location and write permission to the output data location in Amazon S3.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    #[serde(rename = "StoppingCondition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopping_condition: Option<MonitoringStoppingCondition>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeModelExplainabilityJobDefinitionRequest {
    /// <p>The name of the model explainability job definition. The name must be unique within an AWS Region in the AWS account.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeModelExplainabilityJobDefinitionResponse {
    /// <p>The time at which the model explainability job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The Amazon Resource Name (ARN) of the model explainability job.</p>
    #[serde(rename = "JobDefinitionArn")]
    pub job_definition_arn: String,
    /// <p>The name of the explainability job definition. The name must be unique within an AWS Region in the AWS account.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
    #[serde(rename = "JobResources")]
    pub job_resources: MonitoringResources,
    /// <p>Configures the model explainability job to run a specified Docker container image.</p>
    #[serde(rename = "ModelExplainabilityAppSpecification")]
    pub model_explainability_app_specification: ModelExplainabilityAppSpecification,
    /// <p>The baseline configuration for a model explainability job.</p>
    #[serde(rename = "ModelExplainabilityBaselineConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_explainability_baseline_config: Option<ModelExplainabilityBaselineConfig>,
    /// <p>Inputs for the model explainability job.</p>
    #[serde(rename = "ModelExplainabilityJobInput")]
    pub model_explainability_job_input: ModelExplainabilityJobInput,
    #[serde(rename = "ModelExplainabilityJobOutputConfig")]
    pub model_explainability_job_output_config: MonitoringOutputConfig,
    /// <p>Networking options for a model explainability job.</p>
    #[serde(rename = "NetworkConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub network_config: Option<MonitoringNetworkConfig>,
    /// <p>The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM) role that has read permission to the input data location and write permission to the output data location in Amazon S3.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    #[serde(rename = "StoppingCondition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopping_condition: Option<MonitoringStoppingCondition>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeModelInput {
    /// <p>The name of the model.</p>
    #[serde(rename = "ModelName")]
    pub model_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeModelOutput {
    /// <p>The containers in the inference pipeline.</p>
    #[serde(rename = "Containers")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub containers: Option<Vec<ContainerDefinition>>,
    /// <p>A timestamp that shows when the model was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>If <code>True</code>, no inbound or outbound network calls can be made to or from the model container.</p>
    #[serde(rename = "EnableNetworkIsolation")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_network_isolation: Option<bool>,
    /// <p>The Amazon Resource Name (ARN) of the IAM role that you specified for the model.</p>
    #[serde(rename = "ExecutionRoleArn")]
    pub execution_role_arn: String,
    /// <p>The Amazon Resource Name (ARN) of the model.</p>
    #[serde(rename = "ModelArn")]
    pub model_arn: String,
    /// <p>Name of the Amazon SageMaker model.</p>
    #[serde(rename = "ModelName")]
    pub model_name: String,
    /// <p>The location of the primary inference code, associated artifacts, and custom environment map that the inference code uses when it is deployed in production. </p>
    #[serde(rename = "PrimaryContainer")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub primary_container: Option<ContainerDefinition>,
    /// <p>A <a>VpcConfig</a> object that specifies the VPC that this model has access to. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/host-vpc.html">Protect Endpoints by Using an Amazon Virtual Private Cloud</a> </p>
    #[serde(rename = "VpcConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpc_config: Option<VpcConfig>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeModelPackageGroupInput {
    /// <p>The name of the model group to describe.</p>
    #[serde(rename = "ModelPackageGroupName")]
    pub model_package_group_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeModelPackageGroupOutput {
    #[serde(rename = "CreatedBy")]
    pub created_by: UserContext,
    /// <p>The time that the model group was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The Amazon Resource Name (ARN) of the model group.</p>
    #[serde(rename = "ModelPackageGroupArn")]
    pub model_package_group_arn: String,
    /// <p>A description of the model group.</p>
    #[serde(rename = "ModelPackageGroupDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_group_description: Option<String>,
    /// <p>The name of the model group.</p>
    #[serde(rename = "ModelPackageGroupName")]
    pub model_package_group_name: String,
    /// <p>The status of the model group.</p>
    #[serde(rename = "ModelPackageGroupStatus")]
    pub model_package_group_status: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeModelPackageInput {
    /// <p>The name of the model package to describe.</p>
    #[serde(rename = "ModelPackageName")]
    pub model_package_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeModelPackageOutput {
    /// <p>A description provided for the model approval.</p>
    #[serde(rename = "ApprovalDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub approval_description: Option<String>,
    /// <p>Whether the model package is certified for listing on AWS Marketplace.</p>
    #[serde(rename = "CertifyForMarketplace")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub certify_for_marketplace: Option<bool>,
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>A timestamp specifying when the model package was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>Details about inference jobs that can be run with models based on this model package.</p>
    #[serde(rename = "InferenceSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inference_specification: Option<InferenceSpecification>,
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>The last time the model package was modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    #[serde(rename = "MetadataProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_properties: Option<MetadataProperties>,
    /// <p>The approval status of the model package.</p>
    #[serde(rename = "ModelApprovalStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_approval_status: Option<String>,
    /// <p>Metrics for the model.</p>
    #[serde(rename = "ModelMetrics")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_metrics: Option<ModelMetrics>,
    /// <p>The Amazon Resource Name (ARN) of the model package.</p>
    #[serde(rename = "ModelPackageArn")]
    pub model_package_arn: String,
    /// <p>A brief summary of the model package.</p>
    #[serde(rename = "ModelPackageDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_description: Option<String>,
    /// <p>If the model is a versioned model, the name of the model group that the versioned model belongs to.</p>
    #[serde(rename = "ModelPackageGroupName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_group_name: Option<String>,
    /// <p>The name of the model package being described.</p>
    #[serde(rename = "ModelPackageName")]
    pub model_package_name: String,
    /// <p>The current status of the model package.</p>
    #[serde(rename = "ModelPackageStatus")]
    pub model_package_status: String,
    /// <p>Details about the current status of the model package.</p>
    #[serde(rename = "ModelPackageStatusDetails")]
    pub model_package_status_details: ModelPackageStatusDetails,
    /// <p>The version of the model package.</p>
    #[serde(rename = "ModelPackageVersion")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_version: Option<i64>,
    /// <p>Details about the algorithm that was used to create the model package.</p>
    #[serde(rename = "SourceAlgorithmSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_algorithm_specification: Option<SourceAlgorithmSpecification>,
    /// <p>Configurations for one or more transform jobs that Amazon SageMaker runs to test the model package.</p>
    #[serde(rename = "ValidationSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub validation_specification: Option<ModelPackageValidationSpecification>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeModelQualityJobDefinitionRequest {
    /// <p>The name of the model quality job. The name must be unique within an AWS Region in the AWS account.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeModelQualityJobDefinitionResponse {
    /// <p>The time at which the model quality job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The Amazon Resource Name (ARN) of the model quality job.</p>
    #[serde(rename = "JobDefinitionArn")]
    pub job_definition_arn: String,
    /// <p>The name of the quality job definition. The name must be unique within an AWS Region in the AWS account.</p>
    #[serde(rename = "JobDefinitionName")]
    pub job_definition_name: String,
    #[serde(rename = "JobResources")]
    pub job_resources: MonitoringResources,
    /// <p>Configures the model quality job to run a specified Docker container image.</p>
    #[serde(rename = "ModelQualityAppSpecification")]
    pub model_quality_app_specification: ModelQualityAppSpecification,
    /// <p>The baseline configuration for a model quality job.</p>
    #[serde(rename = "ModelQualityBaselineConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_quality_baseline_config: Option<ModelQualityBaselineConfig>,
    /// <p>Inputs for the model quality job.</p>
    #[serde(rename = "ModelQualityJobInput")]
    pub model_quality_job_input: ModelQualityJobInput,
    #[serde(rename = "ModelQualityJobOutputConfig")]
    pub model_quality_job_output_config: MonitoringOutputConfig,
    /// <p>Networking options for a model quality job.</p>
    #[serde(rename = "NetworkConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub network_config: Option<MonitoringNetworkConfig>,
    /// <p>The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume to perform tasks on your behalf.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    #[serde(rename = "StoppingCondition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopping_condition: Option<MonitoringStoppingCondition>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeMonitoringScheduleRequest {
    /// <p>Name of a previously created monitoring schedule.</p>
    #[serde(rename = "MonitoringScheduleName")]
    pub monitoring_schedule_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeMonitoringScheduleResponse {
    /// <p>The time at which the monitoring job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p> The name of the endpoint for the monitoring job.</p>
    #[serde(rename = "EndpointName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endpoint_name: Option<String>,
    /// <p>A string, up to one KB in size, that contains the reason a monitoring job failed, if it failed.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The time at which the monitoring job was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
    /// <p>Describes metadata on the last execution to run, if there was one.</p>
    #[serde(rename = "LastMonitoringExecutionSummary")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_monitoring_execution_summary: Option<MonitoringExecutionSummary>,
    /// <p>The Amazon Resource Name (ARN) of the monitoring schedule.</p>
    #[serde(rename = "MonitoringScheduleArn")]
    pub monitoring_schedule_arn: String,
    /// <p>The configuration object that specifies the monitoring schedule and defines the monitoring job.</p>
    #[serde(rename = "MonitoringScheduleConfig")]
    pub monitoring_schedule_config: MonitoringScheduleConfig,
    /// <p>Name of the monitoring schedule.</p>
    #[serde(rename = "MonitoringScheduleName")]
    pub monitoring_schedule_name: String,
    /// <p>The status of an monitoring job.</p>
    #[serde(rename = "MonitoringScheduleStatus")]
    pub monitoring_schedule_status: String,
    /// <p><p>The type of the monitoring job that this schedule runs. This is one of the following values.</p> <ul> <li> <p> <code>DATA<em>QUALITY</code> - The schedule is for a data quality monitoring job.</p> </li> <li> <p> <code>MODEL</em>QUALITY</code> - The schedule is for a model quality monitoring job.</p> </li> <li> <p> <code>MODEL<em>BIAS</code> - The schedule is for a bias monitoring job.</p> </li> <li> <p> <code>MODEL</em>EXPLAINABILITY</code> - The schedule is for an explainability monitoring job.</p> </li> </ul></p>
    #[serde(rename = "MonitoringType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_type: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeNotebookInstanceInput {
    /// <p>The name of the notebook instance that you want information about.</p>
    #[serde(rename = "NotebookInstanceName")]
    pub notebook_instance_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeNotebookInstanceLifecycleConfigInput {
    /// <p>The name of the lifecycle configuration to describe.</p>
    #[serde(rename = "NotebookInstanceLifecycleConfigName")]
    pub notebook_instance_lifecycle_config_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeNotebookInstanceLifecycleConfigOutput {
    /// <p>A timestamp that tells when the lifecycle configuration was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>A timestamp that tells when the lifecycle configuration was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the lifecycle configuration.</p>
    #[serde(rename = "NotebookInstanceLifecycleConfigArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_instance_lifecycle_config_arn: Option<String>,
    /// <p>The name of the lifecycle configuration.</p>
    #[serde(rename = "NotebookInstanceLifecycleConfigName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_instance_lifecycle_config_name: Option<String>,
    /// <p>The shell script that runs only once, when you create a notebook instance.</p>
    #[serde(rename = "OnCreate")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub on_create: Option<Vec<NotebookInstanceLifecycleHook>>,
    /// <p>The shell script that runs every time you start a notebook instance, including when you create the notebook instance.</p>
    #[serde(rename = "OnStart")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub on_start: Option<Vec<NotebookInstanceLifecycleHook>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeNotebookInstanceOutput {
    /// <p>A list of the Elastic Inference (EI) instance types associated with this notebook instance. Currently only one EI instance type can be associated with a notebook instance. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/ei.html">Using Elastic Inference in Amazon SageMaker</a>.</p>
    #[serde(rename = "AcceleratorTypes")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accelerator_types: Option<Vec<String>>,
    /// <p>An array of up to three Git repositories associated with the notebook instance. These can be either the names of Git repositories stored as resources in your account, or the URL of Git repositories in <a href="https://docs.aws.amazon.com/codecommit/latest/userguide/welcome.html">AWS CodeCommit</a> or in any other Git repository. These repositories are cloned at the same level as the default repository of your notebook instance. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/nbi-git-repo.html">Associating Git Repositories with Amazon SageMaker Notebook Instances</a>.</p>
    #[serde(rename = "AdditionalCodeRepositories")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub additional_code_repositories: Option<Vec<String>>,
    /// <p>A timestamp. Use this parameter to return the time when the notebook instance was created</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The Git repository associated with the notebook instance as its default code repository. This can be either the name of a Git repository stored as a resource in your account, or the URL of a Git repository in <a href="https://docs.aws.amazon.com/codecommit/latest/userguide/welcome.html">AWS CodeCommit</a> or in any other Git repository. When you open a notebook instance, it opens in the directory that contains this repository. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/nbi-git-repo.html">Associating Git Repositories with Amazon SageMaker Notebook Instances</a>.</p>
    #[serde(rename = "DefaultCodeRepository")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_code_repository: Option<String>,
    /// <p>Describes whether Amazon SageMaker provides internet access to the notebook instance. If this value is set to <i>Disabled</i>, the notebook instance does not have internet access, and cannot connect to Amazon SageMaker training and endpoint services.</p> <p>For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/appendix-additional-considerations.html#appendix-notebook-and-internet-access">Notebook Instances Are Internet-Enabled by Default</a>.</p>
    #[serde(rename = "DirectInternetAccess")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub direct_internet_access: Option<String>,
    /// <p>If status is <code>Failed</code>, the reason it failed.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The type of ML compute instance running on the notebook instance.</p>
    #[serde(rename = "InstanceType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub instance_type: Option<String>,
    /// <p>The AWS KMS key ID Amazon SageMaker uses to encrypt data when storing it on the ML storage volume attached to the instance. </p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>A timestamp. Use this parameter to retrieve the time when the notebook instance was last modified. </p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The network interface IDs that Amazon SageMaker created at the time of creating the instance. </p>
    #[serde(rename = "NetworkInterfaceId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub network_interface_id: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the notebook instance.</p>
    #[serde(rename = "NotebookInstanceArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_instance_arn: Option<String>,
    /// <p>Returns the name of a notebook instance lifecycle configuration.</p> <p>For information about notebook instance lifestyle configurations, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/notebook-lifecycle-config.html">Step 2.1: (Optional) Customize a Notebook Instance</a> </p>
    #[serde(rename = "NotebookInstanceLifecycleConfigName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_instance_lifecycle_config_name: Option<String>,
    /// <p>The name of the Amazon SageMaker notebook instance. </p>
    #[serde(rename = "NotebookInstanceName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_instance_name: Option<String>,
    /// <p>The status of the notebook instance.</p>
    #[serde(rename = "NotebookInstanceStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_instance_status: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the IAM role associated with the instance. </p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
    /// <p><p>Whether root access is enabled or disabled for users of the notebook instance.</p> <note> <p>Lifecycle configurations need root access to be able to set up a notebook instance. Because of this, lifecycle configurations associated with a notebook instance always run with root access even if you disable root access for users.</p> </note></p>
    #[serde(rename = "RootAccess")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub root_access: Option<String>,
    /// <p>The IDs of the VPC security groups.</p>
    #[serde(rename = "SecurityGroups")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub security_groups: Option<Vec<String>>,
    /// <p>The ID of the VPC subnet.</p>
    #[serde(rename = "SubnetId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subnet_id: Option<String>,
    /// <p>The URL that you use to connect to the Jupyter notebook that is running in your notebook instance. </p>
    #[serde(rename = "Url")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    /// <p>The size, in GB, of the ML storage volume attached to the notebook instance.</p>
    #[serde(rename = "VolumeSizeInGB")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume_size_in_gb: Option<i64>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribePipelineDefinitionForExecutionRequest {
    /// <p>The Amazon Resource Name (ARN) of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionArn")]
    pub pipeline_execution_arn: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribePipelineDefinitionForExecutionResponse {
    /// <p>The time when the pipeline was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The JSON pipeline definition.</p>
    #[serde(rename = "PipelineDefinition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_definition: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribePipelineExecutionRequest {
    /// <p>The Amazon Resource Name (ARN) of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionArn")]
    pub pipeline_execution_arn: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribePipelineExecutionResponse {
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>The time when the pipeline execution was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>The time when the pipeline execution was modified last.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the pipeline.</p>
    #[serde(rename = "PipelineArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_arn: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_arn: Option<String>,
    /// <p>The description of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_description: Option<String>,
    /// <p>The display name of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionDisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_display_name: Option<String>,
    /// <p>The status of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_status: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribePipelineRequest {
    /// <p>The name of the pipeline to describe.</p>
    #[serde(rename = "PipelineName")]
    pub pipeline_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribePipelineResponse {
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>The time when the pipeline was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>The time when the pipeline was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The time when the pipeline was last run.</p>
    #[serde(rename = "LastRunTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_run_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the pipeline.</p>
    #[serde(rename = "PipelineArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_arn: Option<String>,
    /// <p>The JSON pipeline definition.</p>
    #[serde(rename = "PipelineDefinition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_definition: Option<String>,
    /// <p>The description of the pipeline.</p>
    #[serde(rename = "PipelineDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_description: Option<String>,
    /// <p>The display name of the pipeline.</p>
    #[serde(rename = "PipelineDisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_display_name: Option<String>,
    /// <p>The name of the pipeline.</p>
    #[serde(rename = "PipelineName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_name: Option<String>,
    /// <p>The status of the pipeline execution.</p>
    #[serde(rename = "PipelineStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_status: Option<String>,
    /// <p>The Amazon Resource Name (ARN) that the pipeline uses to execute.</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeProcessingJobRequest {
    /// <p>The name of the processing job. The name must be unique within an AWS Region in the AWS account.</p>
    #[serde(rename = "ProcessingJobName")]
    pub processing_job_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeProcessingJobResponse {
    /// <p>Configures the processing job to run a specified container image.</p>
    #[serde(rename = "AppSpecification")]
    pub app_specification: AppSpecification,
    /// <p>The ARN of an AutoML job associated with this processing job.</p>
    #[serde(rename = "AutoMLJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_ml_job_arn: Option<String>,
    /// <p>The time at which the processing job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The environment variables set in the Docker container.</p>
    #[serde(rename = "Environment")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub environment: Option<::std::collections::HashMap<String, String>>,
    /// <p>An optional string, up to one KB in size, that contains metadata from the processing container when the processing job exits.</p>
    #[serde(rename = "ExitMessage")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub exit_message: Option<String>,
    /// <p>The configuration information used to create an experiment.</p>
    #[serde(rename = "ExperimentConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_config: Option<ExperimentConfig>,
    /// <p>A string, up to one KB in size, that contains the reason a processing job failed, if it failed.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The time at which the processing job was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The ARN of a monitoring schedule for an endpoint associated with this processing job.</p>
    #[serde(rename = "MonitoringScheduleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_schedule_arn: Option<String>,
    /// <p>Networking options for a processing job.</p>
    #[serde(rename = "NetworkConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub network_config: Option<NetworkConfig>,
    /// <p>The time at which the processing job completed.</p>
    #[serde(rename = "ProcessingEndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_end_time: Option<f64>,
    /// <p>The inputs for a processing job.</p>
    #[serde(rename = "ProcessingInputs")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_inputs: Option<Vec<ProcessingInput>>,
    /// <p>The Amazon Resource Name (ARN) of the processing job.</p>
    #[serde(rename = "ProcessingJobArn")]
    pub processing_job_arn: String,
    /// <p>The name of the processing job. The name must be unique within an AWS Region in the AWS account.</p>
    #[serde(rename = "ProcessingJobName")]
    pub processing_job_name: String,
    /// <p>Provides the status of a processing job.</p>
    #[serde(rename = "ProcessingJobStatus")]
    pub processing_job_status: String,
    /// <p>Output configuration for the processing job.</p>
    #[serde(rename = "ProcessingOutputConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_output_config: Option<ProcessingOutputConfig>,
    /// <p>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.</p>
    #[serde(rename = "ProcessingResources")]
    pub processing_resources: ProcessingResources,
    /// <p>The time at which the processing job started.</p>
    #[serde(rename = "ProcessingStartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_start_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume to perform tasks on your behalf.</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
    /// <p>The time limit for how long the processing job is allowed to run.</p>
    #[serde(rename = "StoppingCondition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopping_condition: Option<ProcessingStoppingCondition>,
    /// <p>The ARN of a training job associated with this processing job.</p>
    #[serde(rename = "TrainingJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_job_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeProjectInput {
    /// <p>The name of the project to describe.</p>
    #[serde(rename = "ProjectName")]
    pub project_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeProjectOutput {
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>The time when the project was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The Amazon Resource Name (ARN) of the project.</p>
    #[serde(rename = "ProjectArn")]
    pub project_arn: String,
    /// <p>The description of the project.</p>
    #[serde(rename = "ProjectDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub project_description: Option<String>,
    /// <p>The ID of the project.</p>
    #[serde(rename = "ProjectId")]
    pub project_id: String,
    /// <p>The name of the project.</p>
    #[serde(rename = "ProjectName")]
    pub project_name: String,
    /// <p>The status of the project.</p>
    #[serde(rename = "ProjectStatus")]
    pub project_status: String,
    /// <p>Information about a provisioned service catalog product.</p>
    #[serde(rename = "ServiceCatalogProvisionedProductDetails")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service_catalog_provisioned_product_details:
        Option<ServiceCatalogProvisionedProductDetails>,
    /// <p>Information used to provision a service catalog product. For information, see <a href="https://docs.aws.amazon.com/servicecatalog/latest/adminguide/introduction.html">What is AWS Service Catalog</a>.</p>
    #[serde(rename = "ServiceCatalogProvisioningDetails")]
    pub service_catalog_provisioning_details: ServiceCatalogProvisioningDetails,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeSubscribedWorkteamRequest {
    /// <p>The Amazon Resource Name (ARN) of the subscribed work team to describe.</p>
    #[serde(rename = "WorkteamArn")]
    pub workteam_arn: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeSubscribedWorkteamResponse {
    /// <p>A <code>Workteam</code> instance that contains information about the work team.</p>
    #[serde(rename = "SubscribedWorkteam")]
    pub subscribed_workteam: SubscribedWorkteam,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTrainingJobRequest {
    /// <p>The name of the training job.</p>
    #[serde(rename = "TrainingJobName")]
    pub training_job_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeTrainingJobResponse {
    /// <p>Information about the algorithm used for training, and algorithm metadata. </p>
    #[serde(rename = "AlgorithmSpecification")]
    pub algorithm_specification: AlgorithmSpecification,
    /// <p>The Amazon Resource Name (ARN) of an AutoML job.</p>
    #[serde(rename = "AutoMLJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_ml_job_arn: Option<String>,
    /// <p>The billable time in seconds.</p> <p>You can calculate the savings from using managed spot training using the formula <code>(1 - BillableTimeInSeconds / TrainingTimeInSeconds) * 100</code>. For example, if <code>BillableTimeInSeconds</code> is 100 and <code>TrainingTimeInSeconds</code> is 500, the savings is 80%.</p>
    #[serde(rename = "BillableTimeInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billable_time_in_seconds: Option<i64>,
    #[serde(rename = "CheckpointConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub checkpoint_config: Option<CheckpointConfig>,
    /// <p>A timestamp that indicates when the training job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    #[serde(rename = "DebugHookConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub debug_hook_config: Option<DebugHookConfig>,
    /// <p>Configuration information for Debugger rules for debugging output tensors.</p>
    #[serde(rename = "DebugRuleConfigurations")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub debug_rule_configurations: Option<Vec<DebugRuleConfiguration>>,
    /// <p>Evaluation status of Debugger rules for debugging on a training job.</p>
    #[serde(rename = "DebugRuleEvaluationStatuses")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub debug_rule_evaluation_statuses: Option<Vec<DebugRuleEvaluationStatus>>,
    /// <p>To encrypt all communications between ML compute instances in distributed training, choose <code>True</code>. Encryption provides greater security for distributed training, but training might take longer. How long it takes depends on the amount of communication between compute instances, especially if you use a deep learning algorithms in distributed training.</p>
    #[serde(rename = "EnableInterContainerTrafficEncryption")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_inter_container_traffic_encryption: Option<bool>,
    /// <p>A Boolean indicating whether managed spot training is enabled (<code>True</code>) or not (<code>False</code>).</p>
    #[serde(rename = "EnableManagedSpotTraining")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_managed_spot_training: Option<bool>,
    /// <p>If you want to allow inbound or outbound network calls, except for calls between peers within a training cluster for distributed training, choose <code>True</code>. If you enable network isolation for training jobs that are configured to use a VPC, Amazon SageMaker downloads and uploads customer data and model artifacts through the specified VPC, but the training container does not have network access.</p>
    #[serde(rename = "EnableNetworkIsolation")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_network_isolation: Option<bool>,
    #[serde(rename = "ExperimentConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_config: Option<ExperimentConfig>,
    /// <p>If the training job failed, the reason it failed. </p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>A collection of <code>MetricData</code> objects that specify the names, values, and dates and times that the training algorithm emitted to Amazon CloudWatch.</p>
    #[serde(rename = "FinalMetricDataList")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub final_metric_data_list: Option<Vec<MetricData>>,
    /// <p>Algorithm-specific parameters. </p>
    #[serde(rename = "HyperParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hyper_parameters: Option<::std::collections::HashMap<String, String>>,
    /// <p>An array of <code>Channel</code> objects that describes each data input channel. </p>
    #[serde(rename = "InputDataConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_data_config: Option<Vec<Channel>>,
    /// <p>The Amazon Resource Name (ARN) of the Amazon SageMaker Ground Truth labeling job that created the transform or training job.</p>
    #[serde(rename = "LabelingJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub labeling_job_arn: Option<String>,
    /// <p>A timestamp that indicates when the status of the training job was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>Information about the Amazon S3 location that is configured for storing model artifacts. </p>
    #[serde(rename = "ModelArtifacts")]
    pub model_artifacts: ModelArtifacts,
    /// <p>The S3 path where model artifacts that you configured when creating the job are stored. Amazon SageMaker creates subfolders for model artifacts. </p>
    #[serde(rename = "OutputDataConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_data_config: Option<OutputDataConfig>,
    #[serde(rename = "ProfilerConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub profiler_config: Option<ProfilerConfig>,
    /// <p>Configuration information for Debugger rules for profiling system and framework metrics.</p>
    #[serde(rename = "ProfilerRuleConfigurations")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub profiler_rule_configurations: Option<Vec<ProfilerRuleConfiguration>>,
    /// <p>Evaluation status of Debugger rules for profiling on a training job.</p>
    #[serde(rename = "ProfilerRuleEvaluationStatuses")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub profiler_rule_evaluation_statuses: Option<Vec<ProfilerRuleEvaluationStatus>>,
    /// <p>Profiling status of a training job.</p>
    #[serde(rename = "ProfilingStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub profiling_status: Option<String>,
    /// <p>Resources, including ML compute instances and ML storage volumes, that are configured for model training. </p>
    #[serde(rename = "ResourceConfig")]
    pub resource_config: ResourceConfig,
    /// <p>The AWS Identity and Access Management (IAM) role configured for the training job. </p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
    /// <p><p> Provides detailed information about the state of the training job. For detailed information on the secondary status of the training job, see <code>StatusMessage</code> under <a>SecondaryStatusTransition</a>.</p> <p>Amazon SageMaker provides primary statuses and secondary statuses that apply to each of them:</p> <dl> <dt>InProgress</dt> <dd> <ul> <li> <p> <code>Starting</code> - Starting the training job.</p> </li> <li> <p> <code>Downloading</code> - An optional stage for algorithms that support <code>File</code> training input mode. It indicates that data is being downloaded to the ML storage volumes.</p> </li> <li> <p> <code>Training</code> - Training is in progress.</p> </li> <li> <p> <code>Interrupted</code> - The job stopped because the managed spot training instances were interrupted. </p> </li> <li> <p> <code>Uploading</code> - Training is complete and the model artifacts are being uploaded to the S3 location.</p> </li> </ul> </dd> <dt>Completed</dt> <dd> <ul> <li> <p> <code>Completed</code> - The training job has completed.</p> </li> </ul> </dd> <dt>Failed</dt> <dd> <ul> <li> <p> <code>Failed</code> - The training job has failed. The reason for the failure is returned in the <code>FailureReason</code> field of <code>DescribeTrainingJobResponse</code>.</p> </li> </ul> </dd> <dt>Stopped</dt> <dd> <ul> <li> <p> <code>MaxRuntimeExceeded</code> - The job stopped because it exceeded the maximum allowed runtime.</p> </li> <li> <p> <code>MaxWaitTimeExceeded</code> - The job stopped because it exceeded the maximum allowed wait time.</p> </li> <li> <p> <code>Stopped</code> - The training job has stopped.</p> </li> </ul> </dd> <dt>Stopping</dt> <dd> <ul> <li> <p> <code>Stopping</code> - Stopping the training job.</p> </li> </ul> </dd> </dl> <important> <p>Valid values for <code>SecondaryStatus</code> are subject to change. </p> </important> <p>We no longer support the following secondary statuses:</p> <ul> <li> <p> <code>LaunchingMLInstances</code> </p> </li> <li> <p> <code>PreparingTrainingStack</code> </p> </li> <li> <p> <code>DownloadingTrainingImage</code> </p> </li> </ul></p>
    #[serde(rename = "SecondaryStatus")]
    pub secondary_status: String,
    /// <p>A history of all of the secondary statuses that the training job has transitioned through.</p>
    #[serde(rename = "SecondaryStatusTransitions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub secondary_status_transitions: Option<Vec<SecondaryStatusTransition>>,
    /// <p>Specifies a limit to how long a model training job can run. It also specifies the maximum time to wait for a spot instance. When the job reaches the time limit, Amazon SageMaker ends the training job. Use this API to cap model training costs.</p> <p>To stop a job, Amazon SageMaker sends the algorithm the <code>SIGTERM</code> signal, 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. </p>
    #[serde(rename = "StoppingCondition")]
    pub stopping_condition: StoppingCondition,
    #[serde(rename = "TensorBoardOutputConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tensor_board_output_config: Option<TensorBoardOutputConfig>,
    /// <p>Indicates the time when the training job ends on training instances. You are billed for the time interval between the value of <code>TrainingStartTime</code> and this time. For successful jobs and stopped jobs, this is the time after model artifacts are uploaded. For failed jobs, this is the time when Amazon SageMaker detects a job failure.</p>
    #[serde(rename = "TrainingEndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_end_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the training job.</p>
    #[serde(rename = "TrainingJobArn")]
    pub training_job_arn: String,
    /// <p> Name of the model training job. </p>
    #[serde(rename = "TrainingJobName")]
    pub training_job_name: String,
    /// <p>The status of the training job.</p> <p>Amazon SageMaker provides the following training job statuses:</p> <ul> <li> <p> <code>InProgress</code> - The training is in progress.</p> </li> <li> <p> <code>Completed</code> - The training job has completed.</p> </li> <li> <p> <code>Failed</code> - The training job has failed. To see the reason for the failure, see the <code>FailureReason</code> field in the response to a <code>DescribeTrainingJobResponse</code> call.</p> </li> <li> <p> <code>Stopping</code> - The training job is stopping.</p> </li> <li> <p> <code>Stopped</code> - The training job has stopped.</p> </li> </ul> <p>For more detailed information, see <code>SecondaryStatus</code>. </p>
    #[serde(rename = "TrainingJobStatus")]
    pub training_job_status: String,
    /// <p>Indicates the time when the training job starts on training instances. You are billed for the time interval between this time and the value of <code>TrainingEndTime</code>. The start time in CloudWatch Logs might be later than this time. The difference is due to the time it takes to download the training data and to the size of the training container.</p>
    #[serde(rename = "TrainingStartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_start_time: Option<f64>,
    /// <p>The training time in seconds.</p>
    #[serde(rename = "TrainingTimeInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_time_in_seconds: Option<i64>,
    /// <p>The Amazon Resource Name (ARN) of the associated hyperparameter tuning job if the training job was launched by a hyperparameter tuning job.</p>
    #[serde(rename = "TuningJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tuning_job_arn: Option<String>,
    /// <p>A <a>VpcConfig</a> object that specifies the VPC that this training job has access to. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/train-vpc.html">Protect Training Jobs by Using an Amazon Virtual Private Cloud</a>.</p>
    #[serde(rename = "VpcConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpc_config: Option<VpcConfig>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTransformJobRequest {
    /// <p>The name of the transform job that you want to view details of.</p>
    #[serde(rename = "TransformJobName")]
    pub transform_job_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeTransformJobResponse {
    /// <p>The Amazon Resource Name (ARN) of the AutoML transform job.</p>
    #[serde(rename = "AutoMLJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_ml_job_arn: Option<String>,
    /// <p>Specifies the number of records to include in a mini-batch for an HTTP inference request. A <i>record</i> <i/> is a single unit of input data that inference can be made on. For example, a single line in a CSV file is a record. </p> <p>To enable the batch strategy, you must set <code>SplitType</code> to <code>Line</code>, <code>RecordIO</code>, or <code>TFRecord</code>.</p>
    #[serde(rename = "BatchStrategy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub batch_strategy: Option<String>,
    /// <p>A timestamp that shows when the transform Job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    #[serde(rename = "DataProcessing")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data_processing: Option<DataProcessing>,
    /// <p>The environment variables to set in the Docker container. We support up to 16 key and values entries in the map.</p>
    #[serde(rename = "Environment")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub environment: Option<::std::collections::HashMap<String, String>>,
    #[serde(rename = "ExperimentConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_config: Option<ExperimentConfig>,
    /// <p>If the transform job failed, <code>FailureReason</code> describes why it failed. A transform job creates a log file, which includes error messages, and stores it as an Amazon S3 object. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/logging-cloudwatch.html">Log Amazon SageMaker Events with Amazon CloudWatch</a>.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the Amazon SageMaker Ground Truth labeling job that created the transform or training job.</p>
    #[serde(rename = "LabelingJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub labeling_job_arn: Option<String>,
    /// <p>The maximum number of parallel requests on each instance node that can be launched in a transform job. The default value is 1.</p>
    #[serde(rename = "MaxConcurrentTransforms")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_concurrent_transforms: Option<i64>,
    /// <p>The maximum payload size, in MB, used in the transform job.</p>
    #[serde(rename = "MaxPayloadInMB")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_payload_in_mb: Option<i64>,
    /// <p>The timeout and maximum number of retries for processing a transform job invocation.</p>
    #[serde(rename = "ModelClientConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_client_config: Option<ModelClientConfig>,
    /// <p>The name of the model used in the transform job.</p>
    #[serde(rename = "ModelName")]
    pub model_name: String,
    /// <p>Indicates when the transform job has been completed, or has stopped or failed. You are billed for the time interval between this time and the value of <code>TransformStartTime</code>.</p>
    #[serde(rename = "TransformEndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transform_end_time: Option<f64>,
    /// <p>Describes the dataset to be transformed and the Amazon S3 location where it is stored.</p>
    #[serde(rename = "TransformInput")]
    pub transform_input: TransformInput,
    /// <p>The Amazon Resource Name (ARN) of the transform job.</p>
    #[serde(rename = "TransformJobArn")]
    pub transform_job_arn: String,
    /// <p>The name of the transform job.</p>
    #[serde(rename = "TransformJobName")]
    pub transform_job_name: String,
    /// <p>The status of the transform job. If the transform job failed, the reason is returned in the <code>FailureReason</code> field.</p>
    #[serde(rename = "TransformJobStatus")]
    pub transform_job_status: String,
    /// <p>Identifies the Amazon S3 location where you want Amazon SageMaker to save the results from the transform job.</p>
    #[serde(rename = "TransformOutput")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transform_output: Option<TransformOutput>,
    /// <p>Describes the resources, including ML instance types and ML instance count, to use for the transform job.</p>
    #[serde(rename = "TransformResources")]
    pub transform_resources: TransformResources,
    /// <p>Indicates when the transform job starts on ML instances. You are billed for the time interval between this time and the value of <code>TransformEndTime</code>.</p>
    #[serde(rename = "TransformStartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transform_start_time: Option<f64>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTrialComponentRequest {
    /// <p>The name of the trial component to describe.</p>
    #[serde(rename = "TrialComponentName")]
    pub trial_component_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeTrialComponentResponse {
    /// <p>Who created the component.</p>
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>When the component was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The name of the component as displayed. If <code>DisplayName</code> isn't specified, <code>TrialComponentName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>When the component ended.</p>
    #[serde(rename = "EndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub end_time: Option<f64>,
    /// <p>The input artifacts of the component.</p>
    #[serde(rename = "InputArtifacts")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_artifacts: Option<::std::collections::HashMap<String, TrialComponentArtifact>>,
    /// <p>Who last modified the component.</p>
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>When the component was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    #[serde(rename = "MetadataProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_properties: Option<MetadataProperties>,
    /// <p>The metrics for the component.</p>
    #[serde(rename = "Metrics")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metrics: Option<Vec<TrialComponentMetricSummary>>,
    /// <p>The output artifacts of the component.</p>
    #[serde(rename = "OutputArtifacts")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_artifacts: Option<::std::collections::HashMap<String, TrialComponentArtifact>>,
    /// <p>The hyperparameters of the component.</p>
    #[serde(rename = "Parameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parameters: Option<::std::collections::HashMap<String, TrialComponentParameterValue>>,
    /// <p>The Amazon Resource Name (ARN) of the source and, optionally, the job type.</p>
    #[serde(rename = "Source")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<TrialComponentSource>,
    /// <p>When the component started.</p>
    #[serde(rename = "StartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start_time: Option<f64>,
    /// <p><p>The status of the component. States include:</p> <ul> <li> <p>InProgress</p> </li> <li> <p>Completed</p> </li> <li> <p>Failed</p> </li> </ul></p>
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<TrialComponentStatus>,
    /// <p>The Amazon Resource Name (ARN) of the trial component.</p>
    #[serde(rename = "TrialComponentArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_arn: Option<String>,
    /// <p>The name of the trial component.</p>
    #[serde(rename = "TrialComponentName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_name: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTrialRequest {
    /// <p>The name of the trial to describe.</p>
    #[serde(rename = "TrialName")]
    pub trial_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeTrialResponse {
    /// <p>Who created the trial.</p>
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>When the trial was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The name of the trial as displayed. If <code>DisplayName</code> isn't specified, <code>TrialName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>The name of the experiment the trial is part of.</p>
    #[serde(rename = "ExperimentName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_name: Option<String>,
    /// <p>Who last modified the trial.</p>
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>When the trial was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    #[serde(rename = "MetadataProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_properties: Option<MetadataProperties>,
    /// <p>The Amazon Resource Name (ARN) of the source and, optionally, the job type.</p>
    #[serde(rename = "Source")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<TrialSource>,
    /// <p>The Amazon Resource Name (ARN) of the trial.</p>
    #[serde(rename = "TrialArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_arn: Option<String>,
    /// <p>The name of the trial.</p>
    #[serde(rename = "TrialName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_name: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeUserProfileRequest {
    /// <p>The domain ID.</p>
    #[serde(rename = "DomainId")]
    pub domain_id: String,
    /// <p>The user profile name.</p>
    #[serde(rename = "UserProfileName")]
    pub user_profile_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeUserProfileResponse {
    /// <p>The creation time.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The ID of the domain that contains the profile.</p>
    #[serde(rename = "DomainId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_id: Option<String>,
    /// <p>The failure reason.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The ID of the user's profile in the Amazon Elastic File System (EFS) volume.</p>
    #[serde(rename = "HomeEfsFileSystemUid")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub home_efs_file_system_uid: Option<String>,
    /// <p>The last modified time.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The SSO user identifier.</p>
    #[serde(rename = "SingleSignOnUserIdentifier")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub single_sign_on_user_identifier: Option<String>,
    /// <p>The SSO user value.</p>
    #[serde(rename = "SingleSignOnUserValue")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub single_sign_on_user_value: Option<String>,
    /// <p>The status.</p>
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    /// <p>The user profile Amazon Resource Name (ARN).</p>
    #[serde(rename = "UserProfileArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_profile_arn: Option<String>,
    /// <p>The user profile name.</p>
    #[serde(rename = "UserProfileName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_profile_name: Option<String>,
    /// <p>A collection of settings.</p>
    #[serde(rename = "UserSettings")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_settings: Option<UserSettings>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeWorkforceRequest {
    /// <p>The name of the private workforce whose access you want to restrict. <code>WorkforceName</code> is automatically set to <code>default</code> when a workforce is created and cannot be modified. </p>
    #[serde(rename = "WorkforceName")]
    pub workforce_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeWorkforceResponse {
    /// <p>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 AWS 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 <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-create-private.html">Create a Private Workforce</a>.</p>
    #[serde(rename = "Workforce")]
    pub workforce: Workforce,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeWorkteamRequest {
    /// <p>The name of the work team to return a description of.</p>
    #[serde(rename = "WorkteamName")]
    pub workteam_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeWorkteamResponse {
    /// <p>A <code>Workteam</code> instance that contains information about the work team. </p>
    #[serde(rename = "Workteam")]
    pub workteam: Workteam,
}

/// <p>Specifies weight and capacity values for a production variant.</p>
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DesiredWeightAndCapacity {
    /// <p>The variant's capacity.</p>
    #[serde(rename = "DesiredInstanceCount")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub desired_instance_count: Option<i64>,
    /// <p>The variant's weight.</p>
    #[serde(rename = "DesiredWeight")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub desired_weight: Option<f32>,
    /// <p>The name of the variant to update.</p>
    #[serde(rename = "VariantName")]
    pub variant_name: String,
}

/// <p>Information of a particular device.</p>
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Device {
    /// <p>Description of the device.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The name of the device.</p>
    #[serde(rename = "DeviceName")]
    pub device_name: String,
    /// <p>AWS Internet of Things (IoT) object name.</p>
    #[serde(rename = "IotThingName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub iot_thing_name: Option<String>,
}

/// <p>Summary of the device fleet.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeviceFleetSummary {
    /// <p>Timestamp of when the device fleet was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>Amazon Resource Name (ARN) of the device fleet.</p>
    #[serde(rename = "DeviceFleetArn")]
    pub device_fleet_arn: String,
    /// <p>Name of the device fleet.</p>
    #[serde(rename = "DeviceFleetName")]
    pub device_fleet_name: String,
    /// <p>Timestamp of when the device fleet was last updated.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
}

/// <p>Status of devices.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeviceStats {
    /// <p>The number of devices connected with a heartbeat.</p>
    #[serde(rename = "ConnectedDeviceCount")]
    pub connected_device_count: i64,
    /// <p>The number of registered devices.</p>
    #[serde(rename = "RegisteredDeviceCount")]
    pub registered_device_count: i64,
}

/// <p>Summary of the device.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeviceSummary {
    /// <p>A description of the device.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>Amazon Resource Name (ARN) of the device.</p>
    #[serde(rename = "DeviceArn")]
    pub device_arn: String,
    /// <p>The name of the fleet the device belongs to.</p>
    #[serde(rename = "DeviceFleetName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub device_fleet_name: Option<String>,
    /// <p>The unique identifier of the device.</p>
    #[serde(rename = "DeviceName")]
    pub device_name: String,
    /// <p>The AWS Internet of Things (IoT) object thing name associated with the device..</p>
    #[serde(rename = "IotThingName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub iot_thing_name: Option<String>,
    /// <p>The last heartbeat received from the device.</p>
    #[serde(rename = "LatestHeartbeat")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latest_heartbeat: Option<f64>,
    /// <p>Models on the device.</p>
    #[serde(rename = "Models")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub models: Option<Vec<EdgeModelSummary>>,
    /// <p>The timestamp of the last registration or de-reregistration.</p>
    #[serde(rename = "RegistrationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub registration_time: Option<f64>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisableSagemakerServicecatalogPortfolioInput {}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisableSagemakerServicecatalogPortfolioOutput {}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateTrialComponentRequest {
    /// <p>The name of the component to disassociate from the trial.</p>
    #[serde(rename = "TrialComponentName")]
    pub trial_component_name: String,
    /// <p>The name of the trial to disassociate from.</p>
    #[serde(rename = "TrialName")]
    pub trial_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateTrialComponentResponse {
    /// <p>The Amazon Resource Name (ARN) of the trial.</p>
    #[serde(rename = "TrialArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_arn: Option<String>,
    /// <p>The ARN of the trial component.</p>
    #[serde(rename = "TrialComponentArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_arn: Option<String>,
}

/// <p>The domain's details.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DomainDetails {
    /// <p>The creation time.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The domain's Amazon Resource Name (ARN).</p>
    #[serde(rename = "DomainArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_arn: Option<String>,
    /// <p>The domain ID.</p>
    #[serde(rename = "DomainId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_id: Option<String>,
    /// <p>The domain name.</p>
    #[serde(rename = "DomainName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_name: Option<String>,
    /// <p>The last modified time.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The status.</p>
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    /// <p>The domain's URL.</p>
    #[serde(rename = "Url")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

/// <p>The model on the edge device.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EdgeModel {
    /// <p>The timestamp of the last inference that was made.</p>
    #[serde(rename = "LatestInference")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latest_inference: Option<f64>,
    /// <p>The timestamp of the last data sample taken.</p>
    #[serde(rename = "LatestSampleTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latest_sample_time: Option<f64>,
    /// <p>The name of the model.</p>
    #[serde(rename = "ModelName")]
    pub model_name: String,
    /// <p>The model version.</p>
    #[serde(rename = "ModelVersion")]
    pub model_version: String,
}

/// <p>Status of edge devices with this model.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EdgeModelStat {
    /// <p>The number of devices that have this model version, a heart beat, and are currently running.</p>
    #[serde(rename = "ActiveDeviceCount")]
    pub active_device_count: i64,
    /// <p>The number of devices that have this model version and have a heart beat. </p>
    #[serde(rename = "ConnectedDeviceCount")]
    pub connected_device_count: i64,
    /// <p>The name of the model.</p>
    #[serde(rename = "ModelName")]
    pub model_name: String,
    /// <p>The model version.</p>
    #[serde(rename = "ModelVersion")]
    pub model_version: String,
    /// <p>The number of devices that have this model version and do not have a heart beat.</p>
    #[serde(rename = "OfflineDeviceCount")]
    pub offline_device_count: i64,
    /// <p>The number of devices with this model version and are producing sample data.</p>
    #[serde(rename = "SamplingDeviceCount")]
    pub sampling_device_count: i64,
}

/// <p>Summary of model on edge device.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EdgeModelSummary {
    /// <p>The name of the model.</p>
    #[serde(rename = "ModelName")]
    pub model_name: String,
    /// <p>The version model.</p>
    #[serde(rename = "ModelVersion")]
    pub model_version: String,
}

/// <p>The output configuration.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct EdgeOutputConfig {
    /// <p>The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt data on the storage volume after compilation job. If you don't provide a KMS key ID, Amazon SageMaker uses the default KMS key for Amazon S3 for your role's account.</p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>The Amazon Simple Storage (S3) bucker URI.</p>
    #[serde(rename = "S3OutputLocation")]
    pub s3_output_location: String,
}

/// <p>Summary of edge packaging job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EdgePackagingJobSummary {
    /// <p>The name of the SageMaker Neo compilation job.</p>
    #[serde(rename = "CompilationJobName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub compilation_job_name: Option<String>,
    /// <p>The timestamp of when the job was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the edge packaging job.</p>
    #[serde(rename = "EdgePackagingJobArn")]
    pub edge_packaging_job_arn: String,
    /// <p>The name of the edge packaging job.</p>
    #[serde(rename = "EdgePackagingJobName")]
    pub edge_packaging_job_name: String,
    /// <p>The status of the edge packaging job.</p>
    #[serde(rename = "EdgePackagingJobStatus")]
    pub edge_packaging_job_status: String,
    /// <p>The timestamp of when the edge packaging job was last updated.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The name of the model.</p>
    #[serde(rename = "ModelName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_name: Option<String>,
    /// <p>The version of the model.</p>
    #[serde(rename = "ModelVersion")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_version: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EnableSagemakerServicecatalogPortfolioInput {}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EnableSagemakerServicecatalogPortfolioOutput {}

/// <p>A hosted endpoint for real-time inference.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Endpoint {
    /// <p>The time that the endpoint was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    #[serde(rename = "DataCaptureConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data_capture_config: Option<DataCaptureConfigSummary>,
    /// <p>The Amazon Resource Name (ARN) of the endpoint.</p>
    #[serde(rename = "EndpointArn")]
    pub endpoint_arn: String,
    /// <p>The endpoint configuration associated with the endpoint.</p>
    #[serde(rename = "EndpointConfigName")]
    pub endpoint_config_name: String,
    /// <p>The name of the endpoint.</p>
    #[serde(rename = "EndpointName")]
    pub endpoint_name: String,
    /// <p>The status of the endpoint.</p>
    #[serde(rename = "EndpointStatus")]
    pub endpoint_status: String,
    /// <p>If the endpoint failed, the reason it failed.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The last time the endpoint was modified.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
    /// <p>A list of monitoring schedules for the endpoint. For information about model monitoring, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor.html">Amazon SageMaker Model Monitor</a>.</p>
    #[serde(rename = "MonitoringSchedules")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_schedules: Option<Vec<MonitoringSchedule>>,
    /// <p>A list of the production variants hosted on the endpoint. Each production variant is a model.</p>
    #[serde(rename = "ProductionVariants")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub production_variants: Option<Vec<ProductionVariantSummary>>,
    /// <p>A list of the tags associated with the endpoint. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS resources</a> in the <i>AWS General Reference Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

/// <p>Provides summary information for an endpoint configuration.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EndpointConfigSummary {
    /// <p>A timestamp that shows when the endpoint configuration was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The Amazon Resource Name (ARN) of the endpoint configuration.</p>
    #[serde(rename = "EndpointConfigArn")]
    pub endpoint_config_arn: String,
    /// <p>The name of the endpoint configuration.</p>
    #[serde(rename = "EndpointConfigName")]
    pub endpoint_config_name: String,
}

/// <p>Input object for the endpoint</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct EndpointInput {
    /// <p>If specified, monitoring jobs substract this time from the end time. For information about using offsets for scheduling monitoring jobs, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-model-quality-schedule.html">Schedule Model Quality Monitoring Jobs</a>.</p>
    #[serde(rename = "EndTimeOffset")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub end_time_offset: Option<String>,
    /// <p>An endpoint in customer's account which has enabled <code>DataCaptureConfig</code> enabled.</p>
    #[serde(rename = "EndpointName")]
    pub endpoint_name: String,
    /// <p>The attributes of the input data that are the input features.</p>
    #[serde(rename = "FeaturesAttribute")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub features_attribute: Option<String>,
    /// <p>The attribute of the input data that represents the ground truth label.</p>
    #[serde(rename = "InferenceAttribute")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inference_attribute: Option<String>,
    /// <p>Path to the filesystem where the endpoint data is available to the container.</p>
    #[serde(rename = "LocalPath")]
    pub local_path: String,
    /// <p>In a classification problem, the attribute that represents the class probability.</p>
    #[serde(rename = "ProbabilityAttribute")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub probability_attribute: Option<String>,
    /// <p>The threshold for the class probability to be evaluated as a positive result.</p>
    #[serde(rename = "ProbabilityThresholdAttribute")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub probability_threshold_attribute: Option<f64>,
    /// <p>Whether input data distributed in Amazon S3 is fully replicated or sharded by an S3 key. Defauts to <code>FullyReplicated</code> </p>
    #[serde(rename = "S3DataDistributionType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_data_distribution_type: Option<String>,
    /// <p>Whether the <code>Pipe</code> or <code>File</code> is used as the input mode for transfering data for the monitoring job. <code>Pipe</code> mode is recommended for large datasets. <code>File</code> mode is useful for small files that fit in memory. Defaults to <code>File</code>.</p>
    #[serde(rename = "S3InputMode")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_input_mode: Option<String>,
    /// <p>If specified, monitoring jobs substract this time from the start time. For information about using offsets for scheduling monitoring jobs, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-model-quality-schedule.html">Schedule Model Quality Monitoring Jobs</a>.</p>
    #[serde(rename = "StartTimeOffset")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start_time_offset: Option<String>,
}

/// <p>Provides summary information for an endpoint.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EndpointSummary {
    /// <p>A timestamp that shows when the endpoint was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The Amazon Resource Name (ARN) of the endpoint.</p>
    #[serde(rename = "EndpointArn")]
    pub endpoint_arn: String,
    /// <p>The name of the endpoint.</p>
    #[serde(rename = "EndpointName")]
    pub endpoint_name: String,
    /// <p>The status of the endpoint.</p> <ul> <li> <p> <code>OutOfService</code>: Endpoint is not available to take incoming requests.</p> </li> <li> <p> <code>Creating</code>: <a>CreateEndpoint</a> is executing.</p> </li> <li> <p> <code>Updating</code>: <a>UpdateEndpoint</a> or <a>UpdateEndpointWeightsAndCapacities</a> is executing.</p> </li> <li> <p> <code>SystemUpdating</code>: Endpoint is undergoing maintenance and cannot be updated or deleted or re-scaled until it has completed. This maintenance operation does not change any customer-specified values such as VPC config, KMS encryption, model, instance type, or instance count.</p> </li> <li> <p> <code>RollingBack</code>: Endpoint fails to scale up or down or change its variant weight and is in the process of rolling back to its previous configuration. Once the rollback completes, endpoint returns to an <code>InService</code> status. This transitional status only applies to an endpoint that has autoscaling enabled and is undergoing variant weight or capacity changes as part of an <a>UpdateEndpointWeightsAndCapacities</a> call or when the <a>UpdateEndpointWeightsAndCapacities</a> operation is called explicitly.</p> </li> <li> <p> <code>InService</code>: Endpoint is available to process incoming requests.</p> </li> <li> <p> <code>Deleting</code>: <a>DeleteEndpoint</a> is executing.</p> </li> <li> <p> <code>Failed</code>: Endpoint could not be created, updated, or re-scaled. Use <a>DescribeEndpointOutput$FailureReason</a> for information about the failure. <a>DeleteEndpoint</a> is the only operation that can be performed on a failed endpoint.</p> </li> </ul> <p>To get a list of endpoints with a specified status, use the <a>ListEndpointsInput$StatusEquals</a> filter.</p>
    #[serde(rename = "EndpointStatus")]
    pub endpoint_status: String,
    /// <p>A timestamp that shows when the endpoint was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
}

/// <p>The properties of an experiment as returned by the <a>Search</a> API.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Experiment {
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>When the experiment was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The description of the experiment.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The name of the experiment as displayed. If <code>DisplayName</code> isn't specified, <code>ExperimentName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the experiment.</p>
    #[serde(rename = "ExperimentArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_arn: Option<String>,
    /// <p>The name of the experiment.</p>
    #[serde(rename = "ExperimentName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_name: Option<String>,
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>When the experiment was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    #[serde(rename = "Source")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<ExperimentSource>,
    /// <p>The list of tags that are associated with the experiment. You can use <a>Search</a> API to search on the tags.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

/// <p><p>Associates a SageMaker job as a trial component with an experiment and trial. Specified when you call the following APIs:</p> <ul> <li> <p> <a>CreateProcessingJob</a> </p> </li> <li> <p> <a>CreateTrainingJob</a> </p> </li> <li> <p> <a>CreateTransformJob</a> </p> </li> </ul></p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ExperimentConfig {
    /// <p>The name of an existing experiment to associate the trial component with.</p>
    #[serde(rename = "ExperimentName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_name: Option<String>,
    /// <p>The display name for the trial component. If this key isn't specified, the display name is the trial component name.</p>
    #[serde(rename = "TrialComponentDisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_display_name: Option<String>,
    /// <p>The name of an existing trial to associate the trial component with. If not specified, a new trial is created.</p>
    #[serde(rename = "TrialName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_name: Option<String>,
}

/// <p>The source of the experiment.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ExperimentSource {
    /// <p>The Amazon Resource Name (ARN) of the source.</p>
    #[serde(rename = "SourceArn")]
    pub source_arn: String,
    /// <p>The source type.</p>
    #[serde(rename = "SourceType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_type: Option<String>,
}

/// <p>A summary of the properties of an experiment. To get the complete set of properties, call the <a>DescribeExperiment</a> API and provide the <code>ExperimentName</code>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ExperimentSummary {
    /// <p>When the experiment was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The name of the experiment as displayed. If <code>DisplayName</code> isn't specified, <code>ExperimentName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the experiment.</p>
    #[serde(rename = "ExperimentArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_arn: Option<String>,
    /// <p>The name of the experiment.</p>
    #[serde(rename = "ExperimentName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_name: Option<String>,
    #[serde(rename = "ExperimentSource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_source: Option<ExperimentSource>,
    /// <p>When the experiment was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
}

/// <p>Contains explainability metrics for a model.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Explainability {
    /// <p>The explainability report for a model.</p>
    #[serde(rename = "Report")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub report: Option<MetricsSource>,
}

/// <p>A list of features. You must include <code>FeatureName</code> and <code>FeatureType</code>. Valid feature <code>FeatureType</code>s are <code>Integral</code>, <code>Fractional</code> and <code>String</code>. </p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FeatureDefinition {
    /// <p>The name of a feature. The type must be a string. <code>FeatureName</code> cannot be any of the following: <code>is_deleted</code>, <code>write_time</code>, <code>api_invocation_time</code>.</p>
    #[serde(rename = "FeatureName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub feature_name: Option<String>,
    /// <p>The value type of a feature. Valid values are Integral, Fractional, or String.</p>
    #[serde(rename = "FeatureType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub feature_type: Option<String>,
}

/// <p>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.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FeatureGroup {
    /// <p>The time a <code>FeatureGroup</code> was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>A free form description of a <code>FeatureGroup</code>.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The name of the feature that stores the <code>EventTime</code> of a Record in a <code>FeatureGroup</code>.</p> <p>A <code>EventTime</code> is point in time when a new event occurs that corresponds to the creation or update of a <code>Record</code> in <code>FeatureGroup</code>. All <code>Records</code> in the <code>FeatureGroup</code> must have a corresponding <code>EventTime</code>.</p>
    #[serde(rename = "EventTimeFeatureName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_time_feature_name: Option<String>,
    /// <p>The reason that the <code>FeatureGroup</code> failed to be replicated in the <code>OfflineStore</code>. This is failure may be due to a failure to create a <code>FeatureGroup</code> in or delete a <code>FeatureGroup</code> from the <code>OfflineStore</code>.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>A list of <code>Feature</code>s. Each <code>Feature</code> must include a <code>FeatureName</code> and a <code>FeatureType</code>. </p> <p>Valid <code>FeatureType</code>s are <code>Integral</code>, <code>Fractional</code> and <code>String</code>. </p> <p> <code>FeatureName</code>s cannot be any of the following: <code>is_deleted</code>, <code>write_time</code>, <code>api_invocation_time</code>.</p> <p>You can create up to 2,500 <code>FeatureDefinition</code>s per <code>FeatureGroup</code>.</p>
    #[serde(rename = "FeatureDefinitions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub feature_definitions: Option<Vec<FeatureDefinition>>,
    /// <p>The Amazon Resource Name (ARN) of a <code>FeatureGroup</code>.</p>
    #[serde(rename = "FeatureGroupArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub feature_group_arn: Option<String>,
    /// <p>The name of the <code>FeatureGroup</code>.</p>
    #[serde(rename = "FeatureGroupName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub feature_group_name: Option<String>,
    /// <p>A <code>FeatureGroup</code> status.</p>
    #[serde(rename = "FeatureGroupStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub feature_group_status: Option<String>,
    #[serde(rename = "OfflineStoreConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offline_store_config: Option<OfflineStoreConfig>,
    #[serde(rename = "OfflineStoreStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offline_store_status: Option<OfflineStoreStatus>,
    #[serde(rename = "OnlineStoreConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub online_store_config: Option<OnlineStoreConfig>,
    /// <p>The name of the <code>Feature</code> whose value uniquely identifies a <code>Record</code> defined in the <code>FeatureGroup</code> <code>FeatureDefinitions</code>.</p>
    #[serde(rename = "RecordIdentifierFeatureName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub record_identifier_feature_name: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the IAM execution role used to create the feature group.</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
    /// <p>Tags used to define a <code>FeatureGroup</code>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

/// <p>The name, Arn, <code>CreationTime</code>, <code>FeatureGroup</code> values, <code>LastUpdatedTime</code> and <code>EnableOnlineStorage</code> status of a <code>FeatureGroup</code>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FeatureGroupSummary {
    /// <p>A timestamp indicating the time of creation time of the <code>FeatureGroup</code>.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>Unique identifier for the <code>FeatureGroup</code>.</p>
    #[serde(rename = "FeatureGroupArn")]
    pub feature_group_arn: String,
    /// <p>The name of <code>FeatureGroup</code>.</p>
    #[serde(rename = "FeatureGroupName")]
    pub feature_group_name: String,
    /// <p>The status of a FeatureGroup. The status can be any of the following: <code>Creating</code>, <code>Created</code>, <code>CreateFail</code>, <code>Deleting</code> or <code>DetailFail</code>. </p>
    #[serde(rename = "FeatureGroupStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub feature_group_status: Option<String>,
    /// <p>Notifies you if replicating data into the <code>OfflineStore</code> has failed. Returns either: <code>Active</code> or <code>Blocked</code>.</p>
    #[serde(rename = "OfflineStoreStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offline_store_status: Option<OfflineStoreStatus>,
}

/// <p>The Amazon Elastic File System (EFS) storage configuration for a SageMaker image.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FileSystemConfig {
    /// <p>The default POSIX group ID (GID). If not specified, defaults to <code>100</code>.</p>
    #[serde(rename = "DefaultGid")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_gid: Option<i64>,
    /// <p>The default POSIX user ID (UID). If not specified, defaults to <code>1000</code>.</p>
    #[serde(rename = "DefaultUid")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_uid: Option<i64>,
    /// <p>The path within the image to mount the user's EFS home directory. The directory should be empty. If not specified, defaults to <i>/home/sagemaker-user</i>.</p>
    #[serde(rename = "MountPath")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mount_path: Option<String>,
}

/// <p>Specifies a file system data source for a channel.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FileSystemDataSource {
    /// <p>The full path to the directory to associate with the channel.</p>
    #[serde(rename = "DirectoryPath")]
    pub directory_path: String,
    /// <p>The access mode of the mount of the directory associated with the channel. A directory can be mounted either in <code>ro</code> (read-only) or <code>rw</code> (read-write) mode.</p>
    #[serde(rename = "FileSystemAccessMode")]
    pub file_system_access_mode: String,
    /// <p>The file system id.</p>
    #[serde(rename = "FileSystemId")]
    pub file_system_id: String,
    /// <p>The file system type. </p>
    #[serde(rename = "FileSystemType")]
    pub file_system_type: String,
}

/// <p><p>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 <a>Search</a> API.</p> <p>If you specify a <code>Value</code>, but not an <code>Operator</code>, Amazon SageMaker uses the equals operator.</p> <p>In search, there are several property types:</p> <dl> <dt>Metrics</dt> <dd> <p>To define a metric filter, enter a value using the form <code>&quot;Metrics.&lt;name&gt;&quot;</code>, where <code>&lt;name&gt;</code> is a metric name. For example, the following filter searches for training jobs with an <code>&quot;accuracy&quot;</code> metric greater than <code>&quot;0.9&quot;</code>:</p> <p> <code>{</code> </p> <p> <code>&quot;Name&quot;: &quot;Metrics.accuracy&quot;,</code> </p> <p> <code>&quot;Operator&quot;: &quot;GreaterThan&quot;,</code> </p> <p> <code>&quot;Value&quot;: &quot;0.9&quot;</code> </p> <p> <code>}</code> </p> </dd> <dt>HyperParameters</dt> <dd> <p>To define a hyperparameter filter, enter a value with the form <code>&quot;HyperParameters.&lt;name&gt;&quot;</code>. Decimal hyperparameter values are treated as a decimal in a comparison if the specified <code>Value</code> is also a decimal value. If the specified <code>Value</code> is an integer, the decimal hyperparameter values are treated as integers. For example, the following filter is satisfied by training jobs with a <code>&quot;learning<em>rate&quot;</code> hyperparameter that is less than <code>&quot;0.5&quot;</code>:</p> <p> <code> {</code> </p> <p> <code> &quot;Name&quot;: &quot;HyperParameters.learning</em>rate&quot;,</code> </p> <p> <code> &quot;Operator&quot;: &quot;LessThan&quot;,</code> </p> <p> <code> &quot;Value&quot;: &quot;0.5&quot;</code> </p> <p> <code> }</code> </p> </dd> <dt>Tags</dt> <dd> <p>To define a tag filter, enter a value with the form <code>Tags.&lt;key&gt;</code>.</p> </dd> </dl></p>
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Filter {
    /// <p>A resource property name. For example, <code>TrainingJobName</code>. For valid property names, see <a>SearchRecord</a>. You must specify a valid property for the resource.</p>
    #[serde(rename = "Name")]
    pub name: String,
    /// <p><p>A Boolean binary operator that is used to evaluate the filter. The operator field contains one of the following values:</p> <dl> <dt>Equals</dt> <dd> <p>The value of <code>Name</code> equals <code>Value</code>.</p> </dd> <dt>NotEquals</dt> <dd> <p>The value of <code>Name</code> doesn&#39;t equal <code>Value</code>.</p> </dd> <dt>Exists</dt> <dd> <p>The <code>Name</code> property exists.</p> </dd> <dt>NotExists</dt> <dd> <p>The <code>Name</code> property does not exist.</p> </dd> <dt>GreaterThan</dt> <dd> <p>The value of <code>Name</code> is greater than <code>Value</code>. Not supported for text properties.</p> </dd> <dt>GreaterThanOrEqualTo</dt> <dd> <p>The value of <code>Name</code> is greater than or equal to <code>Value</code>. Not supported for text properties.</p> </dd> <dt>LessThan</dt> <dd> <p>The value of <code>Name</code> is less than <code>Value</code>. Not supported for text properties.</p> </dd> <dt>LessThanOrEqualTo</dt> <dd> <p>The value of <code>Name</code> is less than or equal to <code>Value</code>. Not supported for text properties.</p> </dd> <dt>In</dt> <dd> <p>The value of <code>Name</code> is one of the comma delimited strings in <code>Value</code>. Only supported for text properties.</p> </dd> <dt>Contains</dt> <dd> <p>The value of <code>Name</code> contains the string <code>Value</code>. Only supported for text properties.</p> <p>A <code>SearchExpression</code> can include the <code>Contains</code> operator multiple times when the value of <code>Name</code> is one of the following:</p> <ul> <li> <p> <code>Experiment.DisplayName</code> </p> </li> <li> <p> <code>Experiment.ExperimentName</code> </p> </li> <li> <p> <code>Experiment.Tags</code> </p> </li> <li> <p> <code>Trial.DisplayName</code> </p> </li> <li> <p> <code>Trial.TrialName</code> </p> </li> <li> <p> <code>Trial.Tags</code> </p> </li> <li> <p> <code>TrialComponent.DisplayName</code> </p> </li> <li> <p> <code>TrialComponent.TrialComponentName</code> </p> </li> <li> <p> <code>TrialComponent.Tags</code> </p> </li> <li> <p> <code>TrialComponent.InputArtifacts</code> </p> </li> <li> <p> <code>TrialComponent.OutputArtifacts</code> </p> </li> </ul> <p>A <code>SearchExpression</code> can include only one <code>Contains</code> operator for all other values of <code>Name</code>. In these cases, if you include multiple <code>Contains</code> operators in the <code>SearchExpression</code>, the result is the following error message: &quot;<code>&#39;CONTAINS&#39; operator usage limit of 1 exceeded.</code>&quot;</p> </dd> </dl></p>
    #[serde(rename = "Operator")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub operator: Option<String>,
    /// <p>A value used with <code>Name</code> and <code>Operator</code> to determine which resources satisfy the filter's condition. For numerical properties, <code>Value</code> must be an integer or floating-point decimal. For timestamp properties, <code>Value</code> must be an ISO 8601 date-time string of the following format: <code>YYYY-mm-dd'T'HH:MM:SS</code>.</p>
    #[serde(rename = "Value")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
}

/// <p>The best candidate result from an AutoML training job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FinalAutoMLJobObjectiveMetric {
    /// <p>The name of the metric with the best result. For a description of the possible objective metrics, see <a>AutoMLJobObjective$MetricName</a>.</p>
    #[serde(rename = "MetricName")]
    pub metric_name: String,
    /// <p>The type of metric with the best result.</p>
    #[serde(rename = "Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub type_: Option<String>,
    /// <p>The value of the metric with the best result.</p>
    #[serde(rename = "Value")]
    pub value: f32,
}

/// <p>Shows the final value for the objective metric for a training job that was launched by a hyperparameter tuning job. You define the objective metric in the <code>HyperParameterTuningJobObjective</code> parameter of <a>HyperParameterTuningJobConfig</a>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FinalHyperParameterTuningJobObjectiveMetric {
    /// <p>The name of the objective metric.</p>
    #[serde(rename = "MetricName")]
    pub metric_name: String,
    /// <p>Whether to minimize or maximize the objective metric. Valid values are Minimize and Maximize.</p>
    #[serde(rename = "Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub type_: Option<String>,
    /// <p>The value of the objective metric.</p>
    #[serde(rename = "Value")]
    pub value: f32,
}

/// <p>Contains information about where human output will be stored.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FlowDefinitionOutputConfig {
    /// <p>The Amazon Key Management Service (KMS) key ID for server-side encryption.</p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>The Amazon S3 path where the object containing human output will be made available.</p>
    #[serde(rename = "S3OutputPath")]
    pub s3_output_path: String,
}

/// <p>Contains summary information about the flow definition.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FlowDefinitionSummary {
    /// <p>The timestamp when SageMaker created the flow definition.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The reason why the flow definition creation failed. A failure reason is returned only when the flow definition status is <code>Failed</code>.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the flow definition.</p>
    #[serde(rename = "FlowDefinitionArn")]
    pub flow_definition_arn: String,
    /// <p>The name of the flow definition.</p>
    #[serde(rename = "FlowDefinitionName")]
    pub flow_definition_name: String,
    /// <p>The status of the flow definition. Valid values:</p>
    #[serde(rename = "FlowDefinitionStatus")]
    pub flow_definition_status: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeviceFleetReportRequest {
    /// <p>The name of the fleet.</p>
    #[serde(rename = "DeviceFleetName")]
    pub device_fleet_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDeviceFleetReportResponse {
    /// <p>The versions of Edge Manager agent deployed on the fleet.</p>
    #[serde(rename = "AgentVersions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub agent_versions: Option<Vec<AgentVersion>>,
    /// <p>Description of the fleet.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the device.</p>
    #[serde(rename = "DeviceFleetArn")]
    pub device_fleet_arn: String,
    /// <p>The name of the fleet.</p>
    #[serde(rename = "DeviceFleetName")]
    pub device_fleet_name: String,
    /// <p>Status of devices.</p>
    #[serde(rename = "DeviceStats")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub device_stats: Option<DeviceStats>,
    /// <p>Status of model on device.</p>
    #[serde(rename = "ModelStats")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_stats: Option<Vec<EdgeModelStat>>,
    /// <p>The output configuration for storing sample data collected by the fleet.</p>
    #[serde(rename = "OutputConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_config: Option<EdgeOutputConfig>,
    /// <p>Timestamp of when the report was generated.</p>
    #[serde(rename = "ReportGenerated")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub report_generated: Option<f64>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetModelPackageGroupPolicyInput {
    /// <p>The name of the model group for which to get the resource policy.</p>
    #[serde(rename = "ModelPackageGroupName")]
    pub model_package_group_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetModelPackageGroupPolicyOutput {
    /// <p>The resource policy for the model group.</p>
    #[serde(rename = "ResourcePolicy")]
    pub resource_policy: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSagemakerServicecatalogPortfolioStatusInput {}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSagemakerServicecatalogPortfolioStatusOutput {
    /// <p>Whether Service Catalog is enabled or disabled in SageMaker.</p>
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSearchSuggestionsRequest {
    /// <p>The name of the Amazon SageMaker resource to search for.</p>
    #[serde(rename = "Resource")]
    pub resource: String,
    /// <p>Limits the property names that are included in the response.</p>
    #[serde(rename = "SuggestionQuery")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub suggestion_query: Option<SuggestionQuery>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSearchSuggestionsResponse {
    /// <p>A list of property names for a <code>Resource</code> that match a <code>SuggestionQuery</code>.</p>
    #[serde(rename = "PropertyNameSuggestions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub property_name_suggestions: Option<Vec<PropertyNameSuggestion>>,
}

/// <p>Specifies configuration details for a Git repository in your AWS account.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct GitConfig {
    /// <p>The default branch for the Git repository.</p>
    #[serde(rename = "Branch")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub branch: Option<String>,
    /// <p>The URL where the Git repository is located.</p>
    #[serde(rename = "RepositoryUrl")]
    pub repository_url: String,
    /// <p>The Amazon Resource Name (ARN) of the AWS Secrets Manager secret that contains the credentials used to access the git repository. The secret must have a staging label of <code>AWSCURRENT</code> and must be in the following format:</p> <p> <code>{"username": <i>UserName</i>, "password": <i>Password</i>}</code> </p>
    #[serde(rename = "SecretArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub secret_arn: Option<String>,
}

/// <p>Specifies configuration details for a Git repository when the repository is updated.</p>
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GitConfigForUpdate {
    /// <p>The Amazon Resource Name (ARN) of the AWS Secrets Manager secret that contains the credentials used to access the git repository. The secret must have a staging label of <code>AWSCURRENT</code> and must be in the following format:</p> <p> <code>{"username": <i>UserName</i>, "password": <i>Password</i>}</code> </p>
    #[serde(rename = "SecretArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub secret_arn: Option<String>,
}

/// <p>Defines under what conditions SageMaker creates a human loop. Used within . See for the required format of activation conditions.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HumanLoopActivationConditionsConfig {
    /// <p>JSON expressing use-case specific conditions declaratively. If any condition is matched, atomic tasks are created against the configured work team. The set of conditions is different for Rekognition and Textract. For more information about how to structure the JSON, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/a2i-human-fallback-conditions-json-schema.html">JSON Schema for Human Loop Activation Conditions in Amazon Augmented AI</a> in the <i>Amazon SageMaker Developer Guide</i>.</p>
    #[serde(rename = "HumanLoopActivationConditions")]
    pub human_loop_activation_conditions: String,
}

/// <p>Provides information about how and under what conditions SageMaker creates a human loop. If <code>HumanLoopActivationConfig</code> is not given, then all requests go to humans.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HumanLoopActivationConfig {
    /// <p>Container structure for defining under what conditions SageMaker creates a human loop.</p>
    #[serde(rename = "HumanLoopActivationConditionsConfig")]
    pub human_loop_activation_conditions_config: HumanLoopActivationConditionsConfig,
}

/// <p>Describes the work to be performed by human workers.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HumanLoopConfig {
    /// <p>The Amazon Resource Name (ARN) of the human task user interface.</p>
    #[serde(rename = "HumanTaskUiArn")]
    pub human_task_ui_arn: String,
    #[serde(rename = "PublicWorkforceTaskPrice")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub public_workforce_task_price: Option<PublicWorkforceTaskPrice>,
    /// <p>The length of time that a task remains available for review by human workers.</p>
    #[serde(rename = "TaskAvailabilityLifetimeInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub task_availability_lifetime_in_seconds: Option<i64>,
    /// <p>The number of distinct workers who will perform the same task on each object. For example, if <code>TaskCount</code> is set to <code>3</code> for an image classification labeling job, three workers will classify each input image. Increasing <code>TaskCount</code> can improve label accuracy.</p>
    #[serde(rename = "TaskCount")]
    pub task_count: i64,
    /// <p>A description for the human worker task.</p>
    #[serde(rename = "TaskDescription")]
    pub task_description: String,
    /// <p>Keywords used to describe the task so that workers can discover the task.</p>
    #[serde(rename = "TaskKeywords")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub task_keywords: Option<Vec<String>>,
    /// <p>The amount of time that a worker has to complete a task. The default value is 3,600 seconds (1 hour)</p>
    #[serde(rename = "TaskTimeLimitInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub task_time_limit_in_seconds: Option<i64>,
    /// <p>A title for the human worker task.</p>
    #[serde(rename = "TaskTitle")]
    pub task_title: String,
    /// <p>Amazon Resource Name (ARN) of a team of workers.</p>
    #[serde(rename = "WorkteamArn")]
    pub workteam_arn: String,
}

/// <p>Container for configuring the source of human task requests.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HumanLoopRequestSource {
    /// <p>Specifies whether Amazon Rekognition or Amazon Textract are used as the integration source. The default field settings and JSON parsing rules are different based on the integration source. Valid values:</p>
    #[serde(rename = "AwsManagedHumanLoopRequestSource")]
    pub aws_managed_human_loop_request_source: String,
}

/// <p>Information required for human workers to complete a labeling task.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HumanTaskConfig {
    /// <p>Configures how labels are consolidated across human workers.</p>
    #[serde(rename = "AnnotationConsolidationConfig")]
    pub annotation_consolidation_config: AnnotationConsolidationConfig,
    /// <p>Defines the maximum number of data objects that can be labeled by human workers at the same time. Also referred to as batch size. Each object may have more than one worker at one time. The default value is 1000 objects.</p>
    #[serde(rename = "MaxConcurrentTaskCount")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_concurrent_task_count: Option<i64>,
    /// <p>The number of human workers that will label an object. </p>
    #[serde(rename = "NumberOfHumanWorkersPerDataObject")]
    pub number_of_human_workers_per_data_object: i64,
    /// <p><p>The Amazon Resource Name (ARN) of a Lambda function that is run before a data object is sent to a human worker. Use this function to provide input to a custom labeling job.</p> <p>For <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-task-types.html">built-in task types</a>, use one of the following Amazon SageMaker Ground Truth Lambda function ARNs for <code>PreHumanTaskLambdaArn</code>. For custom labeling workflows, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-custom-templates-step3.html#sms-custom-templates-step3-prelambda">Pre-annotation Lambda</a>. </p> <p> <b>Bounding box</b> - Finds the most similar boxes from different workers based on the Jaccard index of the boxes.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-BoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-BoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-BoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-BoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-BoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-BoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-BoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-BoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-BoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-BoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-BoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-BoundingBox</code> </p> </li> </ul> <p> <b>Image classification</b> - Uses a variant of the Expectation Maximization approach to estimate the true class of an image based on annotations from individual workers.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-ImageMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-ImageMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-ImageMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-ImageMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-ImageMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-ImageMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-ImageMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-ImageMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-ImageMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-ImageMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-ImageMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-ImageMultiClass</code> </p> </li> </ul> <p> <b>Multi-label image classification</b> - Uses a variant of the Expectation Maximization approach to estimate the true classes of an image based on annotations from individual workers.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-ImageMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-ImageMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-ImageMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-ImageMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-ImageMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-ImageMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-ImageMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-ImageMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-ImageMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-ImageMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-ImageMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-ImageMultiClassMultiLabel</code> </p> </li> </ul> <p> <b>Semantic segmentation</b> - Treats each pixel in an image as a multi-class classification and treats pixel annotations from workers as &quot;votes&quot; for the correct label.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-SemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-SemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-SemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-SemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-SemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-SemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-SemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-SemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-SemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-SemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-SemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-SemanticSegmentation</code> </p> </li> </ul> <p> <b>Text classification</b> - Uses a variant of the Expectation Maximization approach to estimate the true class of text based on annotations from individual workers.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-TextMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-TextMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-TextMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-TextMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-TextMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-TextMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-TextMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-TextMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-TextMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-TextMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-TextMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-TextMultiClass</code> </p> </li> </ul> <p> <b>Multi-label text classification</b> - Uses a variant of the Expectation Maximization approach to estimate the true classes of text based on annotations from individual workers.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-TextMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-TextMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-TextMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-TextMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-TextMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-TextMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-TextMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-TextMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-TextMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-TextMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-TextMultiClassMultiLabel</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-TextMultiClassMultiLabel</code> </p> </li> </ul> <p> <b>Named entity recognition</b> - Groups similar selections and calculates aggregate boundaries, resolving to most-assigned label.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-NamedEntityRecognition</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-NamedEntityRecognition</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-NamedEntityRecognition</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-NamedEntityRecognition</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-NamedEntityRecognition</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-NamedEntityRecognition</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-NamedEntityRecognition</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-NamedEntityRecognition</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-NamedEntityRecognition</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-NamedEntityRecognition</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-NamedEntityRecognition</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-NamedEntityRecognition</code> </p> </li> </ul> <p> <b>Video Classification</b> - Use this task type when you need workers to classify videos using predefined labels that you specify. Workers are shown videos and are asked to choose one label for each video.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-VideoMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-VideoMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-VideoMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-VideoMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-VideoMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-VideoMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-VideoMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-VideoMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-VideoMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-VideoMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-VideoMultiClass</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-VideoMultiClass</code> </p> </li> </ul> <p> <b>Video Frame Object Detection</b> - Use this task type to have workers identify and locate objects in a sequence of video frames (images extracted from a video) using bounding boxes. For example, you can use this task to ask workers to identify and localize various objects in a series of video frames, such as cars, bikes, and pedestrians.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-VideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-VideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-VideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-VideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-VideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-VideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-VideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-VideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-VideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-VideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-VideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-VideoObjectDetection</code> </p> </li> </ul> <p> <b>Video Frame Object Tracking</b> - Use this task type to have workers track the movement of objects in a sequence of video frames (images extracted from a video) using bounding boxes. For example, you can use this task to ask workers to track the movement of objects, such as cars, bikes, and pedestrians. </p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-VideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-VideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-VideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-VideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-VideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-VideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-VideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-VideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-VideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-VideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-VideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-VideoObjectTracking</code> </p> </li> </ul> <p> <b>3D Point Cloud Modalities</b> </p> <p>Use the following pre-annotation lambdas for 3D point cloud labeling modality tasks. See <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-point-cloud-task-types.html">3D Point Cloud Task types </a> to learn more. </p> <p> <b>3D Point Cloud Object Detection</b> - Use this task type when you want workers to classify objects in a 3D point cloud by drawing 3D cuboids around objects. For example, you can use this task type to ask workers to identify different types of objects in a point cloud, such as cars, bikes, and pedestrians.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-3DPointCloudObjectDetection</code> </p> </li> </ul> <p> <b>3D Point Cloud Object Tracking</b> - Use this task type when you want workers to draw 3D cuboids around objects that appear in a sequence of 3D point cloud frames. For example, you can use this task type to ask workers to track the movement of vehicles across multiple point cloud frames. </p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-3DPointCloudObjectTracking</code> </p> </li> </ul> <p> <b>3D Point Cloud Semantic Segmentation</b> - Use this task type when you want workers to create a point-level semantic segmentation masks by painting objects in a 3D point cloud using different colors where each color is assigned to one of the classes you specify.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-3DPointCloudSemanticSegmentation</code> </p> </li> </ul> <p> <b>Use the following ARNs for Label Verification and Adjustment Jobs</b> </p> <p>Use label verification and adjustment jobs to review and adjust labels. To learn more, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-verification-data.html">Verify and Adjust Labels </a>.</p> <p> <b>Bounding box verification</b> - Uses a variant of the Expectation Maximization approach to estimate the true class of verification judgement for bounding box labels based on annotations from individual workers.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> </ul> <p> <b>Bounding box adjustment</b> - Finds the most similar boxes from different workers based on the Jaccard index of the adjusted annotations.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-AdjustmentBoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-AdjustmentBoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-AdjustmentBoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-AdjustmentBoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-AdjustmentBoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-AdjustmentBoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-AdjustmentBoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-AdjustmentBoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-AdjustmentBoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-AdjustmentBoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-AdjustmentBoundingBox</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-AdjustmentBoundingBox</code> </p> </li> </ul> <p> <b>Semantic segmentation verification</b> - Uses a variant of the Expectation Maximization approach to estimate the true class of verification judgment for semantic segmentation labels based on annotations from individual workers.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-VerificationSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-VerificationSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-VerificationSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-VerificationSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-VerificationSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-VerificationSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-VerificationSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-VerificationSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-VerificationSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-VerificationSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-VerificationSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-VerificationSemanticSegmentation</code> </p> </li> </ul> <p> <b>Semantic segmentation adjustment</b> - Treats each pixel in an image as a multi-class classification and treats pixel adjusted annotations from workers as &quot;votes&quot; for the correct label.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-AdjustmentSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-AdjustmentSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-AdjustmentSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-AdjustmentSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-AdjustmentSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-AdjustmentSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-AdjustmentSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-AdjustmentSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-AdjustmentSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-AdjustmentSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-AdjustmentSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-AdjustmentSemanticSegmentation</code> </p> </li> </ul> <p> <b>Video Frame Object Detection Adjustment</b> - Use this task type when you want workers to adjust bounding boxes that workers have added to video frames to classify and localize objects in a sequence of video frames.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-AdjustmentVideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-AdjustmentVideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-AdjustmentVideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-AdjustmentVideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-AdjustmentVideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-AdjustmentVideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-AdjustmentVideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-AdjustmentVideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-AdjustmentVideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-AdjustmentVideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-AdjustmentVideoObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-AdjustmentVideoObjectDetection</code> </p> </li> </ul> <p> <b>Video Frame Object Tracking Adjustment</b> - Use this task type when you want workers to adjust bounding boxes that workers have added to video frames to track object movement across a sequence of video frames.</p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-AdjustmentVideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-AdjustmentVideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-AdjustmentVideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-AdjustmentVideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-AdjustmentVideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-AdjustmentVideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-AdjustmentVideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-AdjustmentVideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-AdjustmentVideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-AdjustmentVideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-AdjustmentVideoObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-AdjustmentVideoObjectTracking</code> </p> </li> </ul> <p> <b>3D point cloud object detection adjustment</b> - Adjust 3D cuboids in a point cloud frame. </p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-Adjustment3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-Adjustment3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-Adjustment3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-Adjustment3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-Adjustment3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-Adjustment3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-Adjustment3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-Adjustment3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-Adjustment3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-Adjustment3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-Adjustment3DPointCloudObjectDetection</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-Adjustment3DPointCloudObjectDetection</code> </p> </li> </ul> <p> <b>3D point cloud object tracking adjustment</b> - Adjust 3D cuboids across a sequence of point cloud frames. </p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-Adjustment3DPointCloudObjectTracking</code> </p> </li> </ul> <p> <b>3D point cloud semantic segmentation adjustment</b> - Adjust semantic segmentation masks in a 3D point cloud. </p> <ul> <li> <p> <code>arn:aws:lambda:us-east-1:432418664414:function:PRE-Adjustment3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-east-2:266458841044:function:PRE-Adjustment3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:us-west-2:081040173940:function:PRE-Adjustment3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-1:568282634449:function:PRE-Adjustment3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-1:477331159723:function:PRE-Adjustment3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-2:454466003867:function:PRE-Adjustment3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-south-1:565803892007:function:PRE-Adjustment3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-central-1:203001061592:function:PRE-Adjustment3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-northeast-2:845288260483:function:PRE-Adjustment3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:eu-west-2:487402164563:function:PRE-Adjustment3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ap-southeast-1:377565633583:function:PRE-Adjustment3DPointCloudSemanticSegmentation</code> </p> </li> <li> <p> <code>arn:aws:lambda:ca-central-1:918755190332:function:PRE-Adjustment3DPointCloudSemanticSegmentation</code> </p> </li> </ul></p>
    #[serde(rename = "PreHumanTaskLambdaArn")]
    pub pre_human_task_lambda_arn: String,
    /// <p>The price that you pay for each task performed by an Amazon Mechanical Turk worker.</p>
    #[serde(rename = "PublicWorkforceTaskPrice")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub public_workforce_task_price: Option<PublicWorkforceTaskPrice>,
    /// <p>The length of time that a task remains available for labeling by human workers. <b>If you choose the Amazon Mechanical Turk workforce, the maximum is 12 hours (43200)</b>. The default value is 864000 seconds (10 days). For private and vendor workforces, the maximum is as listed.</p>
    #[serde(rename = "TaskAvailabilityLifetimeInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub task_availability_lifetime_in_seconds: Option<i64>,
    /// <p>A description of the task for your human workers.</p>
    #[serde(rename = "TaskDescription")]
    pub task_description: String,
    /// <p>Keywords used to describe the task so that workers on Amazon Mechanical Turk can discover the task.</p>
    #[serde(rename = "TaskKeywords")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub task_keywords: Option<Vec<String>>,
    /// <p>The amount of time that a worker has to complete a task.</p>
    #[serde(rename = "TaskTimeLimitInSeconds")]
    pub task_time_limit_in_seconds: i64,
    /// <p>A title for the task for your human workers.</p>
    #[serde(rename = "TaskTitle")]
    pub task_title: String,
    /// <p>Information about the user interface that workers use to complete the labeling task.</p>
    #[serde(rename = "UiConfig")]
    pub ui_config: UiConfig,
    /// <p>The Amazon Resource Name (ARN) of the work team assigned to complete the tasks.</p>
    #[serde(rename = "WorkteamArn")]
    pub workteam_arn: String,
}

/// <p>Container for human task user interface information.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HumanTaskUiSummary {
    /// <p>A timestamp when SageMaker created the human task user interface.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The Amazon Resource Name (ARN) of the human task user interface.</p>
    #[serde(rename = "HumanTaskUiArn")]
    pub human_task_ui_arn: String,
    /// <p>The name of the human task user interface.</p>
    #[serde(rename = "HumanTaskUiName")]
    pub human_task_ui_name: String,
}

/// <p>Specifies which training algorithm to use for training jobs that a hyperparameter tuning job launches and the metrics to monitor.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HyperParameterAlgorithmSpecification {
    /// <p>The name of the resource algorithm to use for the hyperparameter tuning job. If you specify a value for this parameter, do not specify a value for <code>TrainingImage</code>.</p>
    #[serde(rename = "AlgorithmName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub algorithm_name: Option<String>,
    /// <p>An array of <a>MetricDefinition</a> objects that specify the metrics that the algorithm emits.</p>
    #[serde(rename = "MetricDefinitions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metric_definitions: Option<Vec<MetricDefinition>>,
    /// <p> The registry path of the Docker image that contains the training algorithm. For information about Docker registry paths for built-in algorithms, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html">Algorithms Provided by Amazon SageMaker: Common Parameters</a>. Amazon SageMaker supports both <code>registry/repository[:tag]</code> and <code>registry/repository[@digest]</code> image path formats. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms.html">Using Your Own Algorithms with Amazon SageMaker</a>.</p>
    #[serde(rename = "TrainingImage")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_image: Option<String>,
    /// <p>The input mode that the algorithm supports: File or Pipe. In File input mode, Amazon SageMaker downloads the training data from Amazon S3 to the storage volume that is attached to the training instance and mounts the directory to the Docker volume for the training container. In Pipe input mode, Amazon SageMaker streams data directly from Amazon S3 to the container. </p> <p>If you specify File mode, make sure that you provision the storage volume that is attached to the training instance with enough capacity to accommodate the training data downloaded from Amazon S3, the model artifacts, and intermediate information.</p> <p/> <p>For more information about input modes, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html">Algorithms</a>. </p>
    #[serde(rename = "TrainingInputMode")]
    pub training_input_mode: String,
}

/// <p>Defines a hyperparameter to be used by an algorithm.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HyperParameterSpecification {
    /// <p>The default value for this hyperparameter. If a default value is specified, a hyperparameter cannot be required.</p>
    #[serde(rename = "DefaultValue")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_value: Option<String>,
    /// <p>A brief description of the hyperparameter.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>Indicates whether this hyperparameter is required.</p>
    #[serde(rename = "IsRequired")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_required: Option<bool>,
    /// <p>Indicates whether this hyperparameter is tunable in a hyperparameter tuning job.</p>
    #[serde(rename = "IsTunable")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_tunable: Option<bool>,
    /// <p>The name of this hyperparameter. The name must be unique.</p>
    #[serde(rename = "Name")]
    pub name: String,
    /// <p>The allowed range for this hyperparameter.</p>
    #[serde(rename = "Range")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub range: Option<ParameterRange>,
    /// <p>The type of this hyperparameter. The valid types are <code>Integer</code>, <code>Continuous</code>, <code>Categorical</code>, and <code>FreeText</code>.</p>
    #[serde(rename = "Type")]
    pub type_: String,
}

/// <p>Defines the training jobs launched by a hyperparameter tuning job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HyperParameterTrainingJobDefinition {
    /// <p>The <a>HyperParameterAlgorithmSpecification</a> object that specifies the resource algorithm to use for the training jobs that the tuning job launches.</p>
    #[serde(rename = "AlgorithmSpecification")]
    pub algorithm_specification: HyperParameterAlgorithmSpecification,
    #[serde(rename = "CheckpointConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub checkpoint_config: Option<CheckpointConfig>,
    /// <p>The job definition name.</p>
    #[serde(rename = "DefinitionName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub definition_name: Option<String>,
    /// <p>To encrypt all communications between ML compute instances in distributed training, choose <code>True</code>. Encryption provides greater security for distributed training, but training might take longer. How long it takes depends on the amount of communication between compute instances, especially if you use a deep learning algorithm in distributed training.</p>
    #[serde(rename = "EnableInterContainerTrafficEncryption")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_inter_container_traffic_encryption: Option<bool>,
    /// <p>A Boolean indicating whether managed spot training is enabled (<code>True</code>) or not (<code>False</code>).</p>
    #[serde(rename = "EnableManagedSpotTraining")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_managed_spot_training: Option<bool>,
    /// <p>Isolates the training container. No inbound or outbound network calls can be made, except for calls between peers within a training cluster for distributed training. If network isolation is used for training jobs that are configured to use a VPC, Amazon SageMaker downloads and uploads customer data and model artifacts through the specified VPC, but the training container does not have network access.</p>
    #[serde(rename = "EnableNetworkIsolation")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_network_isolation: Option<bool>,
    #[serde(rename = "HyperParameterRanges")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hyper_parameter_ranges: Option<ParameterRanges>,
    /// <p>An array of <a>Channel</a> objects that specify the input for the training jobs that the tuning job launches.</p>
    #[serde(rename = "InputDataConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_data_config: Option<Vec<Channel>>,
    /// <p>Specifies the path to the Amazon S3 bucket where you store model artifacts from the training jobs that the tuning job launches.</p>
    #[serde(rename = "OutputDataConfig")]
    pub output_data_config: OutputDataConfig,
    /// <p>The resources, including the compute instances and storage volumes, to use for the training jobs that the tuning job launches.</p> <p>Storage volumes store model artifacts and incremental states. Training algorithms might also use storage volumes for scratch space. If you want Amazon SageMaker to use the storage volume to store the training data, choose <code>File</code> as the <code>TrainingInputMode</code> in the algorithm specification. For distributed training algorithms, specify an instance count greater than 1.</p>
    #[serde(rename = "ResourceConfig")]
    pub resource_config: ResourceConfig,
    /// <p>The Amazon Resource Name (ARN) of the IAM role associated with the training jobs that the tuning job launches.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    /// <p>Specifies the values of hyperparameters that do not change for the tuning job.</p>
    #[serde(rename = "StaticHyperParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub static_hyper_parameters: Option<::std::collections::HashMap<String, String>>,
    /// <p>Specifies a limit to how long a model hyperparameter training job can run. It also specifies how long you are willing to wait for a managed spot training job to complete. When the job reaches the a limit, Amazon SageMaker ends the training job. Use this API to cap model training costs.</p>
    #[serde(rename = "StoppingCondition")]
    pub stopping_condition: StoppingCondition,
    #[serde(rename = "TuningObjective")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tuning_objective: Option<HyperParameterTuningJobObjective>,
    /// <p>The <a>VpcConfig</a> object that specifies the VPC that you want the training jobs that this hyperparameter tuning job launches to connect to. Control access to and from your training container by configuring the VPC. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/train-vpc.html">Protect Training Jobs by Using an Amazon Virtual Private Cloud</a>.</p>
    #[serde(rename = "VpcConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpc_config: Option<VpcConfig>,
}

/// <p>Specifies summary information about a training job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HyperParameterTrainingJobSummary {
    /// <p>The date and time that the training job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The reason that the training job failed. </p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The <a>FinalHyperParameterTuningJobObjectiveMetric</a> object that specifies the value of the objective metric of the tuning job that launched this training job.</p>
    #[serde(rename = "FinalHyperParameterTuningJobObjectiveMetric")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub final_hyper_parameter_tuning_job_objective_metric:
        Option<FinalHyperParameterTuningJobObjectiveMetric>,
    /// <p><p>The status of the objective metric for the training job:</p> <ul> <li> <p>Succeeded: The final objective metric for the training job was evaluated by the hyperparameter tuning job and used in the hyperparameter tuning process.</p> </li> </ul> <ul> <li> <p>Pending: The training job is in progress and evaluation of its final objective metric is pending.</p> </li> </ul> <ul> <li> <p>Failed: The final objective metric for the training job was not evaluated, and was not used in the hyperparameter tuning process. This typically occurs when the training job failed or did not emit an objective metric.</p> </li> </ul></p>
    #[serde(rename = "ObjectiveStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub objective_status: Option<String>,
    /// <p>Specifies the time when the training job ends on training instances. You are billed for the time interval between the value of <code>TrainingStartTime</code> and this time. For successful jobs and stopped jobs, this is the time after model artifacts are uploaded. For failed jobs, this is the time when Amazon SageMaker detects a job failure.</p>
    #[serde(rename = "TrainingEndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_end_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the training job.</p>
    #[serde(rename = "TrainingJobArn")]
    pub training_job_arn: String,
    /// <p>The training job definition name.</p>
    #[serde(rename = "TrainingJobDefinitionName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_job_definition_name: Option<String>,
    /// <p>The name of the training job.</p>
    #[serde(rename = "TrainingJobName")]
    pub training_job_name: String,
    /// <p>The status of the training job.</p>
    #[serde(rename = "TrainingJobStatus")]
    pub training_job_status: String,
    /// <p>The date and time that the training job started.</p>
    #[serde(rename = "TrainingStartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_start_time: Option<f64>,
    /// <p>A list of the hyperparameters for which you specified ranges to search.</p>
    #[serde(rename = "TunedHyperParameters")]
    pub tuned_hyper_parameters: ::std::collections::HashMap<String, String>,
    /// <p>The HyperParameter tuning job that launched the training job.</p>
    #[serde(rename = "TuningJobName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tuning_job_name: Option<String>,
}

/// <p>Configures a hyperparameter tuning job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HyperParameterTuningJobConfig {
    /// <p>The <a>HyperParameterTuningJobObjective</a> object that specifies the objective metric for this tuning job.</p>
    #[serde(rename = "HyperParameterTuningJobObjective")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hyper_parameter_tuning_job_objective: Option<HyperParameterTuningJobObjective>,
    /// <p>The <a>ParameterRanges</a> object that specifies the ranges of hyperparameters that this tuning job searches.</p>
    #[serde(rename = "ParameterRanges")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parameter_ranges: Option<ParameterRanges>,
    /// <p>The <a>ResourceLimits</a> object that specifies the maximum number of training jobs and parallel training jobs for this tuning job.</p>
    #[serde(rename = "ResourceLimits")]
    pub resource_limits: ResourceLimits,
    /// <p>Specifies how hyperparameter tuning chooses the combinations of hyperparameter values to use for the training job it launches. To use the Bayesian search strategy, set this to <code>Bayesian</code>. To randomly search, set it to <code>Random</code>. For information about search strategies, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-how-it-works.html">How Hyperparameter Tuning Works</a>.</p>
    #[serde(rename = "Strategy")]
    pub strategy: String,
    /// <p><p>Specifies whether to use early stopping for training jobs launched by the hyperparameter tuning job. This can be one of the following values (the default value is <code>OFF</code>):</p> <dl> <dt>OFF</dt> <dd> <p>Training jobs launched by the hyperparameter tuning job do not use early stopping.</p> </dd> <dt>AUTO</dt> <dd> <p>Amazon SageMaker stops training jobs launched by the hyperparameter tuning job when they are unlikely to perform better than previously completed training jobs. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-early-stopping.html">Stop Training Jobs Early</a>.</p> </dd> </dl></p>
    #[serde(rename = "TrainingJobEarlyStoppingType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_job_early_stopping_type: Option<String>,
    /// <p>The tuning job's completion criteria.</p>
    #[serde(rename = "TuningJobCompletionCriteria")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tuning_job_completion_criteria: Option<TuningJobCompletionCriteria>,
}

/// <p>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 <code>Type</code> parameter.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HyperParameterTuningJobObjective {
    /// <p>The name of the metric to use for the objective metric.</p>
    #[serde(rename = "MetricName")]
    pub metric_name: String,
    /// <p>Whether to minimize or maximize the objective metric.</p>
    #[serde(rename = "Type")]
    pub type_: String,
}

/// <p>Provides summary information about a hyperparameter tuning job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HyperParameterTuningJobSummary {
    /// <p>The date and time that the tuning job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The date and time that the tuning job ended.</p>
    #[serde(rename = "HyperParameterTuningEndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hyper_parameter_tuning_end_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the tuning job.</p>
    #[serde(rename = "HyperParameterTuningJobArn")]
    pub hyper_parameter_tuning_job_arn: String,
    /// <p>The name of the tuning job.</p>
    #[serde(rename = "HyperParameterTuningJobName")]
    pub hyper_parameter_tuning_job_name: String,
    /// <p>The status of the tuning job.</p>
    #[serde(rename = "HyperParameterTuningJobStatus")]
    pub hyper_parameter_tuning_job_status: String,
    /// <p>The date and time that the tuning job was modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The <a>ObjectiveStatusCounters</a> object that specifies the numbers of training jobs, categorized by objective metric status, that this tuning job launched.</p>
    #[serde(rename = "ObjectiveStatusCounters")]
    pub objective_status_counters: ObjectiveStatusCounters,
    /// <p>The <a>ResourceLimits</a> object that specifies the maximum number of training jobs and parallel training jobs allowed for this tuning job.</p>
    #[serde(rename = "ResourceLimits")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resource_limits: Option<ResourceLimits>,
    /// <p>Specifies the search strategy hyperparameter tuning uses to choose which hyperparameters to use for each iteration. Currently, the only valid value is Bayesian.</p>
    #[serde(rename = "Strategy")]
    pub strategy: String,
    /// <p>The <a>TrainingJobStatusCounters</a> object that specifies the numbers of training jobs, categorized by status, that this tuning job launched.</p>
    #[serde(rename = "TrainingJobStatusCounters")]
    pub training_job_status_counters: TrainingJobStatusCounters,
}

/// <p><p>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.</p> <p>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.</p> <note> <p>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.</p> </note></p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HyperParameterTuningJobWarmStartConfig {
    /// <p>An array of hyperparameter tuning jobs that are used as the starting point for the new hyperparameter tuning job. For more information about warm starting a hyperparameter tuning job, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-warm-start.html">Using a Previous Hyperparameter Tuning Job as a Starting Point</a>.</p> <p>Hyperparameter tuning jobs created before October 1, 2018 cannot be used as parent jobs for warm start tuning jobs.</p>
    #[serde(rename = "ParentHyperParameterTuningJobs")]
    pub parent_hyper_parameter_tuning_jobs: Vec<ParentHyperParameterTuningJob>,
    /// <p><p>Specifies one of the following:</p> <dl> <dt>IDENTICAL<em>DATA</em>AND<em>ALGORITHM</dt> <dd> <p>The new hyperparameter tuning job uses the same input data and training image as the parent tuning jobs. You can change the hyperparameter ranges to search and the maximum number of training jobs that the hyperparameter tuning job launches. You cannot use a new version of the training algorithm, unless the changes in the new version do not affect the algorithm itself. For example, changes that improve logging or adding support for a different data format are allowed. You can also change hyperparameters from tunable to static, and from static to tunable, but the total number of static plus tunable hyperparameters must remain the same as it is in all parent jobs. The objective metric for the new tuning job must be the same as for all parent jobs.</p> </dd> <dt>TRANSFER</em>LEARNING</dt> <dd> <p>The new hyperparameter tuning job can include input data, hyperparameter ranges, maximum number of concurrent training jobs, and maximum number of training jobs that are different than those of its parent hyperparameter tuning jobs. The training image can also be a different version from the version used in the parent hyperparameter tuning job. You can also change hyperparameters from tunable to static, and from static to tunable, but the total number of static plus tunable hyperparameters must remain the same as it is in all parent jobs. The objective metric for the new tuning job must be the same as for all parent jobs.</p> </dd> </dl></p>
    #[serde(rename = "WarmStartType")]
    pub warm_start_type: String,
}

/// <p>A SageMaker image. A SageMaker 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 <code>ImageVersion</code>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Image {
    /// <p>When the image was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The description of the image.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The name of the image as displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>When a create, update, or delete operation fails, the reason for the failure.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the image.</p>
    #[serde(rename = "ImageArn")]
    pub image_arn: String,
    /// <p>The name of the image.</p>
    #[serde(rename = "ImageName")]
    pub image_name: String,
    /// <p>The status of the image.</p>
    #[serde(rename = "ImageStatus")]
    pub image_status: String,
    /// <p>When the image was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
}

/// <p>Specifies whether the model container is in Amazon ECR or a private Docker registry accessible from your Amazon Virtual Private Cloud (VPC).</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ImageConfig {
    /// <p><p>Set this to one of the following values:</p> <ul> <li> <p> <code>Platform</code> - The model image is hosted in Amazon ECR.</p> </li> <li> <p> <code>Vpc</code> - The model image is hosted in a private Docker registry in your VPC.</p> </li> </ul></p>
    #[serde(rename = "RepositoryAccessMode")]
    pub repository_access_mode: String,
}

/// <p>A version of a SageMaker <code>Image</code>. A version represents an existing container image.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ImageVersion {
    /// <p>When the version was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>When a create or delete operation fails, the reason for the failure.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the image the version is based on.</p>
    #[serde(rename = "ImageArn")]
    pub image_arn: String,
    /// <p>The ARN of the version.</p>
    #[serde(rename = "ImageVersionArn")]
    pub image_version_arn: String,
    /// <p>The status of the version.</p>
    #[serde(rename = "ImageVersionStatus")]
    pub image_version_status: String,
    /// <p>When the version was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
    /// <p>The version number.</p>
    #[serde(rename = "Version")]
    pub version: i64,
}

/// <p>Defines how to perform inference generation after a training job is run.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct InferenceSpecification {
    /// <p>The Amazon ECR registry path of the Docker image that contains the inference code.</p>
    #[serde(rename = "Containers")]
    pub containers: Vec<ModelPackageContainerDefinition>,
    /// <p>The supported MIME types for the input data.</p>
    #[serde(rename = "SupportedContentTypes")]
    pub supported_content_types: Vec<String>,
    /// <p>A list of the instance types that are used to generate inferences in real-time.</p> <p>This parameter is required for unversioned models, and optional for versioned models.</p>
    #[serde(rename = "SupportedRealtimeInferenceInstanceTypes")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub supported_realtime_inference_instance_types: Option<Vec<String>>,
    /// <p>The supported MIME types for the output data.</p>
    #[serde(rename = "SupportedResponseMIMETypes")]
    pub supported_response_mime_types: Vec<String>,
    /// <p>A list of the instance types on which a transformation job can be run or on which an endpoint can be deployed.</p> <p>This parameter is required for unversioned models, and optional for versioned models.</p>
    #[serde(rename = "SupportedTransformInstanceTypes")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub supported_transform_instance_types: Option<Vec<String>>,
}

/// <p>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.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct InputConfig {
    /// <p><p>Specifies the name and shape of the expected data inputs for your trained model with a JSON dictionary form. The data inputs are <a>InputConfig$Framework</a> specific. </p> <ul> <li> <p> <code>TensorFlow</code>: You must specify the name and shape (NHWC format) of the expected data inputs using a dictionary format for your trained model. The dictionary formats required for the console and CLI are different.</p> <ul> <li> <p>Examples for one input:</p> <ul> <li> <p>If using the console, <code>{&quot;input&quot;:[1,1024,1024,3]}</code> </p> </li> <li> <p>If using the CLI, <code>{&quot;input&quot;:[1,1024,1024,3]}</code> </p> </li> </ul> </li> <li> <p>Examples for two inputs:</p> <ul> <li> <p>If using the console, <code>{&quot;data1&quot;: [1,28,28,1], &quot;data2&quot;:[1,28,28,1]}</code> </p> </li> <li> <p>If using the CLI, <code>{&quot;data1&quot;: [1,28,28,1], &quot;data2&quot;:[1,28,28,1]}</code> </p> </li> </ul> </li> </ul> </li> <li> <p> <code>KERAS</code>: You must specify the name and shape (NCHW format) of expected data inputs using a dictionary format for your trained model. Note that while Keras model artifacts should be uploaded in NHWC (channel-last) format, <code>DataInputConfig</code> should be specified in NCHW (channel-first) format. The dictionary formats required for the console and CLI are different.</p> <ul> <li> <p>Examples for one input:</p> <ul> <li> <p>If using the console, <code>{&quot;input<em>1&quot;:[1,3,224,224]}</code> </p> </li> <li> <p>If using the CLI, <code>{&quot;input</em>1&quot;:[1,3,224,224]}</code> </p> </li> </ul> </li> <li> <p>Examples for two inputs:</p> <ul> <li> <p>If using the console, <code>{&quot;input<em>1&quot;: [1,3,224,224], &quot;input</em>2&quot;:[1,3,224,224]} </code> </p> </li> <li> <p>If using the CLI, <code>{&quot;input<em>1&quot;: [1,3,224,224], &quot;input</em>2&quot;:[1,3,224,224]}</code> </p> </li> </ul> </li> </ul> </li> <li> <p> <code>MXNET/ONNX/DARKNET</code>: You must specify the name and shape (NCHW format) of the expected data inputs in order using a dictionary format for your trained model. The dictionary formats required for the console and CLI are different.</p> <ul> <li> <p>Examples for one input:</p> <ul> <li> <p>If using the console, <code>{&quot;data&quot;:[1,3,1024,1024]}</code> </p> </li> <li> <p>If using the CLI, <code>{&quot;data&quot;:[1,3,1024,1024]}</code> </p> </li> </ul> </li> <li> <p>Examples for two inputs:</p> <ul> <li> <p>If using the console, <code>{&quot;var1&quot;: [1,1,28,28], &quot;var2&quot;:[1,1,28,28]} </code> </p> </li> <li> <p>If using the CLI, <code>{&quot;var1&quot;: [1,1,28,28], &quot;var2&quot;:[1,1,28,28]}</code> </p> </li> </ul> </li> </ul> </li> <li> <p> <code>PyTorch</code>: You can either specify the name and shape (NCHW format) of expected data inputs in order using a dictionary format for your trained model or you can specify the shape only using a list format. The dictionary formats required for the console and CLI are different. The list formats for the console and CLI are the same.</p> <ul> <li> <p>Examples for one input in dictionary format:</p> <ul> <li> <p>If using the console, <code>{&quot;input0&quot;:[1,3,224,224]}</code> </p> </li> <li> <p>If using the CLI, <code>{&quot;input0&quot;:[1,3,224,224]}</code> </p> </li> </ul> </li> <li> <p>Example for one input in list format: <code>[[1,3,224,224]]</code> </p> </li> <li> <p>Examples for two inputs in dictionary format:</p> <ul> <li> <p>If using the console, <code>{&quot;input0&quot;:[1,3,224,224], &quot;input1&quot;:[1,3,224,224]}</code> </p> </li> <li> <p>If using the CLI, <code>{&quot;input0&quot;:[1,3,224,224], &quot;input1&quot;:[1,3,224,224]} </code> </p> </li> </ul> </li> <li> <p>Example for two inputs in list format: <code>[[1,3,224,224], [1,3,224,224]]</code> </p> </li> </ul> </li> <li> <p> <code>XGBOOST</code>: input data name and shape are not needed.</p> </li> </ul> <p> <code>DataInputConfig</code> supports the following parameters for <code>CoreML</code> <a>OutputConfig$TargetDevice</a> (ML Model format):</p> <ul> <li> <p> <code>shape</code>: Input shape, for example <code>{&quot;input<em>1&quot;: {&quot;shape&quot;: [1,224,224,3]}}</code>. In addition to static input shapes, CoreML converter supports Flexible input shapes:</p> <ul> <li> <p>Range Dimension. You can use the Range Dimension feature if you know the input shape will be within some specific interval in that dimension, for example: <code>{&quot;input</em>1&quot;: {&quot;shape&quot;: [&quot;1..10&quot;, 224, 224, 3]}}</code> </p> </li> <li> <p>Enumerated shapes. Sometimes, the models are trained to work only on a select set of inputs. You can enumerate all supported input shapes, for example: <code>{&quot;input<em>1&quot;: {&quot;shape&quot;: [[1, 224, 224, 3], [1, 160, 160, 3]]}}</code> </p> </li> </ul> </li> <li> <p> <code>default</em>shape</code>: Default input shape. You can set a default shape during conversion for both Range Dimension and Enumerated Shapes. For example <code>{&quot;input<em>1&quot;: {&quot;shape&quot;: [&quot;1..10&quot;, 224, 224, 3], &quot;default</em>shape&quot;: [1, 224, 224, 3]}}</code> </p> </li> <li> <p> <code>type</code>: Input type. Allowed values: <code>Image</code> and <code>Tensor</code>. By default, the converter generates an ML Model with inputs of type Tensor (MultiArray). User can set input type to be Image. Image input type requires additional input parameters such as <code>bias</code> and <code>scale</code>.</p> </li> <li> <p> <code>bias</code>: If the input type is an Image, you need to provide the bias vector.</p> </li> <li> <p> <code>scale</code>: If the input type is an Image, you need to provide a scale factor.</p> </li> </ul> <p>CoreML <code>ClassifierConfig</code> parameters can be specified using <a>OutputConfig$CompilerOptions</a>. CoreML converter supports Tensorflow and PyTorch models. CoreML conversion examples:</p> <ul> <li> <p>Tensor type input:</p> <ul> <li> <p> <code>&quot;DataInputConfig&quot;: {&quot;input<em>1&quot;: {&quot;shape&quot;: [[1,224,224,3], [1,160,160,3]], &quot;default</em>shape&quot;: [1,224,224,3]}}</code> </p> </li> </ul> </li> <li> <p>Tensor type input without input name (PyTorch):</p> <ul> <li> <p> <code>&quot;DataInputConfig&quot;: [{&quot;shape&quot;: [[1,3,224,224], [1,3,160,160]], &quot;default<em>shape&quot;: [1,3,224,224]}]</code> </p> </li> </ul> </li> <li> <p>Image type input:</p> <ul> <li> <p> <code>&quot;DataInputConfig&quot;: {&quot;input</em>1&quot;: {&quot;shape&quot;: [[1,224,224,3], [1,160,160,3]], &quot;default<em>shape&quot;: [1,224,224,3], &quot;type&quot;: &quot;Image&quot;, &quot;bias&quot;: [-1,-1,-1], &quot;scale&quot;: 0.007843137255}}</code> </p> </li> <li> <p> <code>&quot;CompilerOptions&quot;: {&quot;class</em>labels&quot;: &quot;imagenet<em>labels</em>1000.txt&quot;}</code> </p> </li> </ul> </li> <li> <p>Image type input without input name (PyTorch):</p> <ul> <li> <p> <code>&quot;DataInputConfig&quot;: [{&quot;shape&quot;: [[1,3,224,224], [1,3,160,160]], &quot;default<em>shape&quot;: [1,3,224,224], &quot;type&quot;: &quot;Image&quot;, &quot;bias&quot;: [-1,-1,-1], &quot;scale&quot;: 0.007843137255}]</code> </p> </li> <li> <p> <code>&quot;CompilerOptions&quot;: {&quot;class</em>labels&quot;: &quot;imagenet<em>labels</em>1000.txt&quot;}</code> </p> </li> </ul> </li> </ul></p>
    #[serde(rename = "DataInputConfig")]
    pub data_input_config: String,
    /// <p>Identifies the framework in which the model was trained. For example: TENSORFLOW.</p>
    #[serde(rename = "Framework")]
    pub framework: String,
    /// <p>The S3 path where the model artifacts, which result from model training, are stored. This path must point to a single gzip compressed tar archive (.tar.gz suffix).</p>
    #[serde(rename = "S3Uri")]
    pub s3_uri: String,
}

/// <p>For a hyperparameter of the integer type, specifies the range that a hyperparameter tuning job searches.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct IntegerParameterRange {
    /// <p>The maximum value of the hyperparameter to search.</p>
    #[serde(rename = "MaxValue")]
    pub max_value: String,
    /// <p>The minimum value of the hyperparameter to search.</p>
    #[serde(rename = "MinValue")]
    pub min_value: String,
    /// <p>The name of the hyperparameter to search.</p>
    #[serde(rename = "Name")]
    pub name: String,
    /// <p><p>The scale that hyperparameter tuning uses to search the hyperparameter range. For information about choosing a hyperparameter scale, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-define-ranges.html#scaling-type">Hyperparameter Scaling</a>. One of the following values:</p> <dl> <dt>Auto</dt> <dd> <p>Amazon SageMaker hyperparameter tuning chooses the best scale for the hyperparameter.</p> </dd> <dt>Linear</dt> <dd> <p>Hyperparameter tuning searches the values in the hyperparameter range by using a linear scale.</p> </dd> <dt>Logarithmic</dt> <dd> <p>Hyperparameter tuning searches the values in the hyperparameter range by using a logarithmic scale.</p> <p>Logarithmic scaling works only for ranges that have only values greater than 0.</p> </dd> </dl></p>
    #[serde(rename = "ScalingType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub scaling_type: Option<String>,
}

/// <p>Defines the possible values for an integer hyperparameter.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct IntegerParameterRangeSpecification {
    /// <p>The maximum integer value allowed.</p>
    #[serde(rename = "MaxValue")]
    pub max_value: String,
    /// <p>The minimum integer value allowed.</p>
    #[serde(rename = "MinValue")]
    pub min_value: String,
}

/// <p>The JupyterServer app settings.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct JupyterServerAppSettings {
    /// <p>The default instance type and the Amazon Resource Name (ARN) of the default SageMaker image used by the JupyterServer app.</p>
    #[serde(rename = "DefaultResourceSpec")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_resource_spec: Option<ResourceSpec>,
}

/// <p>The KernelGateway app settings.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct KernelGatewayAppSettings {
    /// <p>A list of custom SageMaker images that are configured to run as a KernelGateway app.</p>
    #[serde(rename = "CustomImages")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub custom_images: Option<Vec<CustomImage>>,
    /// <p>The default instance type and the Amazon Resource Name (ARN) of the default SageMaker image used by the KernelGateway app.</p>
    #[serde(rename = "DefaultResourceSpec")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_resource_spec: Option<ResourceSpec>,
}

/// <p>The configuration for the file system and kernels in a SageMaker image running as a KernelGateway app.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct KernelGatewayImageConfig {
    /// <p>The Amazon Elastic File System (EFS) storage configuration for a SageMaker image.</p>
    #[serde(rename = "FileSystemConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file_system_config: Option<FileSystemConfig>,
    /// <p>The specification of the Jupyter kernels in the image.</p>
    #[serde(rename = "KernelSpecs")]
    pub kernel_specs: Vec<KernelSpec>,
}

/// <p>The specification of a Jupyter kernel.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct KernelSpec {
    /// <p>The display name of the kernel.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>The name of the kernel.</p>
    #[serde(rename = "Name")]
    pub name: String,
}

/// <p>Provides a breakdown of the number of objects labeled.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LabelCounters {
    /// <p>The total number of objects that could not be labeled due to an error.</p>
    #[serde(rename = "FailedNonRetryableError")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failed_non_retryable_error: Option<i64>,
    /// <p>The total number of objects labeled by a human worker.</p>
    #[serde(rename = "HumanLabeled")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub human_labeled: Option<i64>,
    /// <p>The total number of objects labeled by automated data labeling.</p>
    #[serde(rename = "MachineLabeled")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub machine_labeled: Option<i64>,
    /// <p>The total number of objects labeled.</p>
    #[serde(rename = "TotalLabeled")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub total_labeled: Option<i64>,
    /// <p>The total number of objects not yet labeled.</p>
    #[serde(rename = "Unlabeled")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unlabeled: Option<i64>,
}

/// <p>Provides counts for human-labeled tasks in the labeling job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LabelCountersForWorkteam {
    /// <p>The total number of data objects labeled by a human worker.</p>
    #[serde(rename = "HumanLabeled")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub human_labeled: Option<i64>,
    /// <p>The total number of data objects that need to be labeled by a human worker.</p>
    #[serde(rename = "PendingHuman")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pending_human: Option<i64>,
    /// <p>The total number of tasks in the labeling job.</p>
    #[serde(rename = "Total")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// <p>Provides configuration information for auto-labeling of your data objects. A <code>LabelingJobAlgorithmsConfig</code> object must be supplied in order to use auto-labeling.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LabelingJobAlgorithmsConfig {
    /// <p>At the end of an auto-label job Ground Truth sends the Amazon Resource Name (ARN) of the final model used for auto-labeling. You can use this model as the starting point for subsequent similar jobs by providing the ARN of the model here. </p>
    #[serde(rename = "InitialActiveLearningModelArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub initial_active_learning_model_arn: Option<String>,
    /// <p><p>Specifies the Amazon Resource Name (ARN) of the algorithm used for auto-labeling. You must select one of the following ARNs:</p> <ul> <li> <p> <i>Image classification</i> </p> <p> <code>arn:aws:sagemaker:<i>region</i>:027400017018:labeling-job-algorithm-specification/image-classification</code> </p> </li> <li> <p> <i>Text classification</i> </p> <p> <code>arn:aws:sagemaker:<i>region</i>:027400017018:labeling-job-algorithm-specification/text-classification</code> </p> </li> <li> <p> <i>Object detection</i> </p> <p> <code>arn:aws:sagemaker:<i>region</i>:027400017018:labeling-job-algorithm-specification/object-detection</code> </p> </li> <li> <p> <i>Semantic Segmentation</i> </p> <p> <code>arn:aws:sagemaker:<i>region</i>:027400017018:labeling-job-algorithm-specification/semantic-segmentation</code> </p> </li> </ul></p>
    #[serde(rename = "LabelingJobAlgorithmSpecificationArn")]
    pub labeling_job_algorithm_specification_arn: String,
    /// <p>Provides configuration information for a labeling job.</p>
    #[serde(rename = "LabelingJobResourceConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub labeling_job_resource_config: Option<LabelingJobResourceConfig>,
}

/// <p>Attributes of the data specified by the customer. Use these to describe the data to be labeled.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LabelingJobDataAttributes {
    /// <p>Declares that your content is free of personally identifiable information or adult content. Amazon SageMaker may restrict the Amazon Mechanical Turk workers that can view your task based on this information.</p>
    #[serde(rename = "ContentClassifiers")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content_classifiers: Option<Vec<String>>,
}

/// <p>Provides information about the location of input data.</p> <p>You must specify at least one of the following: <code>S3DataSource</code> or <code>SnsDataSource</code>.</p> <p>Use <code>SnsDataSource</code> to 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.</p> <p>Use <code>S3DataSource</code> to specify an input manifest file for both streaming and one-time labeling jobs. Adding an <code>S3DataSource</code> is optional if you use <code>SnsDataSource</code> to create a streaming labeling job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LabelingJobDataSource {
    /// <p>The Amazon S3 location of the input data objects.</p>
    #[serde(rename = "S3DataSource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_data_source: Option<LabelingJobS3DataSource>,
    /// <p>An Amazon SNS data source used for streaming labeling jobs.</p>
    #[serde(rename = "SnsDataSource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sns_data_source: Option<LabelingJobSnsDataSource>,
}

/// <p>Provides summary information for a work team.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LabelingJobForWorkteamSummary {
    /// <p>The date and time that the labeling job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>A unique identifier for a labeling job. You can use this to refer to a specific labeling job.</p>
    #[serde(rename = "JobReferenceCode")]
    pub job_reference_code: String,
    /// <p>Provides information about the progress of a labeling job.</p>
    #[serde(rename = "LabelCounters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub label_counters: Option<LabelCountersForWorkteam>,
    /// <p>The name of the labeling job that the work team is assigned to.</p>
    #[serde(rename = "LabelingJobName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub labeling_job_name: Option<String>,
    /// <p>The configured number of workers per data object.</p>
    #[serde(rename = "NumberOfHumanWorkersPerDataObject")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub number_of_human_workers_per_data_object: Option<i64>,
    /// <p><p/></p>
    #[serde(rename = "WorkRequesterAccountId")]
    pub work_requester_account_id: String,
}

/// <p>Input configuration information for a labeling job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LabelingJobInputConfig {
    /// <p>Attributes of the data specified by the customer.</p>
    #[serde(rename = "DataAttributes")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data_attributes: Option<LabelingJobDataAttributes>,
    /// <p>The location of the input data.</p>
    #[serde(rename = "DataSource")]
    pub data_source: LabelingJobDataSource,
}

/// <p>Specifies the location of the output produced by the labeling job. </p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LabelingJobOutput {
    /// <p>The Amazon Resource Name (ARN) for the most recent Amazon SageMaker model trained as part of automated data labeling. </p>
    #[serde(rename = "FinalActiveLearningModelArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub final_active_learning_model_arn: Option<String>,
    /// <p>The Amazon S3 bucket location of the manifest file for labeled data. </p>
    #[serde(rename = "OutputDatasetS3Uri")]
    pub output_dataset_s3_uri: String,
}

/// <p>Output configuration information for a labeling job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LabelingJobOutputConfig {
    /// <p>The AWS Key Management Service ID of the key used to encrypt the output data, if any.</p> <p>If you use a KMS key ID or an alias of your master key, the Amazon SageMaker execution role must include permissions to call <code>kms:Encrypt</code>. If you don't provide a KMS key ID, Amazon SageMaker uses the default KMS key for Amazon S3 for your role's account. Amazon SageMaker uses server-side encryption with KMS-managed keys for <code>LabelingJobOutputConfig</code>. If you use a bucket policy with an <code>s3:PutObject</code> permission that only allows objects with server-side encryption, set the condition key of <code>s3:x-amz-server-side-encryption</code> to <code>"aws:kms"</code>. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html">KMS-Managed Encryption Keys</a> in the <i>Amazon Simple Storage Service Developer Guide.</i> </p> <p>The KMS key policy must grant permission to the IAM role that you specify in your <code>CreateLabelingJob</code> request. For more information, see <a href="http://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html">Using Key Policies in AWS KMS</a> in the <i>AWS Key Management Service Developer Guide</i>.</p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>The Amazon S3 location to write output data.</p>
    #[serde(rename = "S3OutputPath")]
    pub s3_output_path: String,
    /// <p>An Amazon Simple Notification Service (Amazon SNS) output topic ARN.</p> <p>When workers complete labeling tasks, Ground Truth will send labeling task output data to the SNS output topic you specify here.</p> <p>You must provide a value for this parameter if you provide an Amazon SNS input topic in <code>SnsDataSource</code> in <code>InputConfig</code>.</p>
    #[serde(rename = "SnsTopicArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sns_topic_arn: Option<String>,
}

/// <p>Provides configuration information for labeling jobs.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LabelingJobResourceConfig {
    /// <p><p>The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt data on the storage volume attached to the ML compute instance(s) that run the training job. The <code>VolumeKmsKeyId</code> can be any of the following formats:</p> <ul> <li> <p>// KMS Key ID</p> <p> <code>&quot;1234abcd-12ab-34cd-56ef-1234567890ab&quot;</code> </p> </li> <li> <p>// Amazon Resource Name (ARN) of a KMS Key</p> <p> <code>&quot;arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab&quot;</code> </p> </li> </ul></p>
    #[serde(rename = "VolumeKmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume_kms_key_id: Option<String>,
}

/// <p>The Amazon S3 location of the input data objects.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LabelingJobS3DataSource {
    /// <p>The Amazon S3 location of the manifest file that describes the input data objects.</p>
    #[serde(rename = "ManifestS3Uri")]
    pub manifest_s3_uri: String,
}

/// <p>An Amazon SNS data source used for streaming labeling jobs.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LabelingJobSnsDataSource {
    /// <p>The Amazon SNS input topic Amazon Resource Name (ARN). Specify the ARN of the input topic you will use to send new data objects to a streaming labeling job.</p> <p>If you specify an input topic for <code>SnsTopicArn</code> in <code>InputConfig</code>, you must specify a value for <code>SnsTopicArn</code> in <code>OutputConfig</code>.</p>
    #[serde(rename = "SnsTopicArn")]
    pub sns_topic_arn: String,
}

/// <p><p>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.</p> <note> <p>Labeling jobs fail after 30 days with an appropriate client error message.</p> </note></p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LabelingJobStoppingConditions {
    /// <p>The maximum number of objects that can be labeled by human workers.</p>
    #[serde(rename = "MaxHumanLabeledObjectCount")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_human_labeled_object_count: Option<i64>,
    /// <p>The maximum number of input data objects that should be labeled.</p>
    #[serde(rename = "MaxPercentageOfInputDatasetLabeled")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_percentage_of_input_dataset_labeled: Option<i64>,
}

/// <p>Provides summary information about a labeling job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LabelingJobSummary {
    /// <p>The Amazon Resource Name (ARN) of the Lambda function used to consolidate the annotations from individual workers into a label for a data object. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-annotation-consolidation.html">Annotation Consolidation</a>.</p>
    #[serde(rename = "AnnotationConsolidationLambdaArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub annotation_consolidation_lambda_arn: Option<String>,
    /// <p>The date and time that the job was created (timestamp).</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>If the <code>LabelingJobStatus</code> field is <code>Failed</code>, this field contains a description of the error.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>Input configuration for the labeling job.</p>
    #[serde(rename = "InputConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_config: Option<LabelingJobInputConfig>,
    /// <p>Counts showing the progress of the labeling job.</p>
    #[serde(rename = "LabelCounters")]
    pub label_counters: LabelCounters,
    /// <p>The Amazon Resource Name (ARN) assigned to the labeling job when it was created.</p>
    #[serde(rename = "LabelingJobArn")]
    pub labeling_job_arn: String,
    /// <p>The name of the labeling job.</p>
    #[serde(rename = "LabelingJobName")]
    pub labeling_job_name: String,
    /// <p>The location of the output produced by the labeling job.</p>
    #[serde(rename = "LabelingJobOutput")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub labeling_job_output: Option<LabelingJobOutput>,
    /// <p>The current status of the labeling job. </p>
    #[serde(rename = "LabelingJobStatus")]
    pub labeling_job_status: String,
    /// <p>The date and time that the job was last modified (timestamp).</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
    /// <p>The Amazon Resource Name (ARN) of a Lambda function. The function is run before each data object is sent to a worker.</p>
    #[serde(rename = "PreHumanTaskLambdaArn")]
    pub pre_human_task_lambda_arn: String,
    /// <p>The Amazon Resource Name (ARN) of the work team assigned to the job.</p>
    #[serde(rename = "WorkteamArn")]
    pub workteam_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListActionsRequest {
    /// <p>A filter that returns only actions of the specified type.</p>
    #[serde(rename = "ActionType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub action_type: Option<String>,
    /// <p>A filter that returns only actions created on or after the specified time.</p>
    #[serde(rename = "CreatedAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_after: Option<f64>,
    /// <p>A filter that returns only actions created on or before the specified time.</p>
    #[serde(rename = "CreatedBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_before: Option<f64>,
    /// <p>The maximum number of actions to return in the response. The default value is 10.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the previous call to <code>ListActions</code> didn't return the full set of actions, the call returns a token for getting the next set of actions.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The property used to sort results. The default value is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order. The default value is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that returns only actions with the specified source URI.</p>
    #[serde(rename = "SourceUri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_uri: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListActionsResponse {
    /// <p>A list of actions and their properties.</p>
    #[serde(rename = "ActionSummaries")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub action_summaries: Option<Vec<ActionSummary>>,
    /// <p>A token for getting the next set of actions, if there are any.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAlgorithmsInput {
    /// <p>A filter that returns only algorithms created after the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only algorithms created before the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>The maximum number of algorithms to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the algorithm name. This filter returns only algorithms whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the response to a previous <code>ListAlgorithms</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of algorithms, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The parameter by which to sort the results. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for the results. The default is <code>Ascending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAlgorithmsOutput {
    /// <p>&gt;An array of <code>AlgorithmSummary</code> objects, each of which lists an algorithm.</p>
    #[serde(rename = "AlgorithmSummaryList")]
    pub algorithm_summary_list: Vec<AlgorithmSummary>,
    /// <p>If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of algorithms, use it in the subsequent request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAppImageConfigsRequest {
    /// <p>A filter that returns only AppImageConfigs created on or after the specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only AppImageConfigs created on or before the specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>The maximum number of AppImageConfigs to return in the response. The default value is 10. </p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A filter that returns only AppImageConfigs modified on or after the specified time.</p>
    #[serde(rename = "ModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub modified_time_after: Option<f64>,
    /// <p>A filter that returns only AppImageConfigs modified on or before the specified time.</p>
    #[serde(rename = "ModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub modified_time_before: Option<f64>,
    /// <p>A filter that returns only AppImageConfigs whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the previous call to <code>ListImages</code> didn't return the full set of AppImageConfigs, the call returns a token for getting the next set of AppImageConfigs.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The property used to sort results. The default value is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order. The default value is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAppImageConfigsResponse {
    /// <p>A list of AppImageConfigs and their properties.</p>
    #[serde(rename = "AppImageConfigs")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_image_configs: Option<Vec<AppImageConfigDetails>>,
    /// <p>A token for getting the next set of AppImageConfigs, if there are any.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAppsRequest {
    /// <p>A parameter to search for the domain ID.</p>
    #[serde(rename = "DomainIdEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_id_equals: Option<String>,
    /// <p>Returns a list up to a specified limit.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the previous response was truncated, you will receive this token. Use it in your next request to receive the next set of results.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The parameter by which to sort the results. The default is CreationTime.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for the results. The default is Ascending.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A parameter to search by user profile name.</p>
    #[serde(rename = "UserProfileNameEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_profile_name_equals: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAppsResponse {
    /// <p>The list of apps.</p>
    #[serde(rename = "Apps")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub apps: Option<Vec<AppDetails>>,
    /// <p>If the previous response was truncated, you will receive this token. Use it in your next request to receive the next set of results.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListArtifactsRequest {
    /// <p>A filter that returns only artifacts of the specified type.</p>
    #[serde(rename = "ArtifactType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artifact_type: Option<String>,
    /// <p>A filter that returns only artifacts created on or after the specified time.</p>
    #[serde(rename = "CreatedAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_after: Option<f64>,
    /// <p>A filter that returns only artifacts created on or before the specified time.</p>
    #[serde(rename = "CreatedBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_before: Option<f64>,
    /// <p>The maximum number of artifacts to return in the response. The default value is 10.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the previous call to <code>ListArtifacts</code> didn't return the full set of artifacts, the call returns a token for getting the next set of artifacts.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The property used to sort results. The default value is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order. The default value is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that returns only artifacts with the specified source URI.</p>
    #[serde(rename = "SourceUri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_uri: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListArtifactsResponse {
    /// <p>A list of artifacts and their properties.</p>
    #[serde(rename = "ArtifactSummaries")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artifact_summaries: Option<Vec<ArtifactSummary>>,
    /// <p>A token for getting the next set of artifacts, if there are any.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAssociationsRequest {
    /// <p>A filter that returns only associations of the specified type.</p>
    #[serde(rename = "AssociationType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub association_type: Option<String>,
    /// <p>A filter that returns only associations created on or after the specified time.</p>
    #[serde(rename = "CreatedAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_after: Option<f64>,
    /// <p>A filter that returns only associations created on or before the specified time.</p>
    #[serde(rename = "CreatedBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_before: Option<f64>,
    /// <p>A filter that returns only associations with the specified destination Amazon Resource Name (ARN).</p>
    #[serde(rename = "DestinationArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub destination_arn: Option<String>,
    /// <p>A filter that returns only associations with the specified destination type.</p>
    #[serde(rename = "DestinationType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub destination_type: Option<String>,
    /// <p>The maximum number of associations to return in the response. The default value is 10.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the previous call to <code>ListAssociations</code> didn't return the full set of associations, the call returns a token for getting the next set of associations.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The property used to sort results. The default value is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order. The default value is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that returns only associations with the specified source ARN.</p>
    #[serde(rename = "SourceArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_arn: Option<String>,
    /// <p>A filter that returns only associations with the specified source type.</p>
    #[serde(rename = "SourceType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_type: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAssociationsResponse {
    /// <p>A list of associations and their properties.</p>
    #[serde(rename = "AssociationSummaries")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub association_summaries: Option<Vec<AssociationSummary>>,
    /// <p>A token for getting the next set of associations, if there are any.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAutoMLJobsRequest {
    /// <p>Request a list of jobs, using a filter for time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>Request a list of jobs, using a filter for time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>Request a list of jobs, using a filter for time.</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>Request a list of jobs, using a filter for time.</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>Request a list of jobs up to a specified limit.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>Request a list of jobs, using a search filter for name.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the previous response was truncated, you receive this token. Use it in your next request to receive the next set of results.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The parameter by which to sort the results. The default is AutoMLJobName.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for the results. The default is Descending.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>Request a list of jobs, using a filter for status.</p>
    #[serde(rename = "StatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_equals: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAutoMLJobsResponse {
    /// <p>Returns a summary list of jobs.</p>
    #[serde(rename = "AutoMLJobSummaries")]
    pub auto_ml_job_summaries: Vec<AutoMLJobSummary>,
    /// <p>If the previous response was truncated, you receive this token. Use it in your next request to receive the next set of results.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListCandidatesForAutoMLJobRequest {
    /// <p>List the Candidates created for the job by providing the job's name.</p>
    #[serde(rename = "AutoMLJobName")]
    pub auto_ml_job_name: String,
    /// <p>List the Candidates for the job and filter by candidate name.</p>
    #[serde(rename = "CandidateNameEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub candidate_name_equals: Option<String>,
    /// <p>List the job's Candidates up to a specified limit.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the previous response was truncated, you receive this token. Use it in your next request to receive the next set of results.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The parameter by which to sort the results. The default is Descending.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for the results. The default is Ascending.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>List the Candidates for the job and filter by status.</p>
    #[serde(rename = "StatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_equals: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListCandidatesForAutoMLJobResponse {
    /// <p>Summaries about the Candidates.</p>
    #[serde(rename = "Candidates")]
    pub candidates: Vec<AutoMLCandidate>,
    /// <p>If the previous response was truncated, you receive this token. Use it in your next request to receive the next set of results.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListCodeRepositoriesInput {
    /// <p>A filter that returns only Git repositories that were created after the specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only Git repositories that were created before the specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>A filter that returns only Git repositories that were last modified after the specified time.</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>A filter that returns only Git repositories that were last modified before the specified time.</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>The maximum number of Git repositories to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the Git repositories name. This filter returns only repositories whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of a <code>ListCodeRepositoriesOutput</code> request was truncated, the response includes a <code>NextToken</code>. To get the next set of Git repositories, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The field to sort results by. The default is <code>Name</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Ascending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListCodeRepositoriesOutput {
    /// <p><p>Gets a list of summaries of the Git repositories. Each summary specifies the following values for the repository: </p> <ul> <li> <p>Name</p> </li> <li> <p>Amazon Resource Name (ARN)</p> </li> <li> <p>Creation time</p> </li> <li> <p>Last modified time</p> </li> <li> <p>Configuration information, including the URL location of the repository and the ARN of the AWS Secrets Manager secret that contains the credentials used to access the repository.</p> </li> </ul></p>
    #[serde(rename = "CodeRepositorySummaryList")]
    pub code_repository_summary_list: Vec<CodeRepositorySummary>,
    /// <p>If the result of a <code>ListCodeRepositoriesOutput</code> request was truncated, the response includes a <code>NextToken</code>. To get the next set of Git repositories, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListCompilationJobsRequest {
    /// <p>A filter that returns the model compilation jobs that were created after a specified time. </p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns the model compilation jobs that were created before a specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>A filter that returns the model compilation jobs that were modified after a specified time.</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>A filter that returns the model compilation jobs that were modified before a specified time.</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>The maximum number of model compilation jobs to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A filter that returns the model compilation jobs whose name contains a specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of the previous <code>ListCompilationJobs</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of model compilation jobs, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The field by which to sort results. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Ascending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that retrieves model compilation jobs with a specific <a>DescribeCompilationJobResponse$CompilationJobStatus</a> status.</p>
    #[serde(rename = "StatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_equals: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListCompilationJobsResponse {
    /// <p>An array of <a>CompilationJobSummary</a> objects, each describing a model compilation job. </p>
    #[serde(rename = "CompilationJobSummaries")]
    pub compilation_job_summaries: Vec<CompilationJobSummary>,
    /// <p>If the response is truncated, Amazon SageMaker returns this <code>NextToken</code>. To retrieve the next set of model compilation jobs, use this token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListContextsRequest {
    /// <p>A filter that returns only contexts of the specified type.</p>
    #[serde(rename = "ContextType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context_type: Option<String>,
    /// <p>A filter that returns only contexts created on or after the specified time.</p>
    #[serde(rename = "CreatedAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_after: Option<f64>,
    /// <p>A filter that returns only contexts created on or before the specified time.</p>
    #[serde(rename = "CreatedBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_before: Option<f64>,
    /// <p>The maximum number of contexts to return in the response. The default value is 10.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the previous call to <code>ListContexts</code> didn't return the full set of contexts, the call returns a token for getting the next set of contexts.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The property used to sort results. The default value is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order. The default value is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that returns only contexts with the specified source URI.</p>
    #[serde(rename = "SourceUri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_uri: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListContextsResponse {
    /// <p>A list of contexts and their properties.</p>
    #[serde(rename = "ContextSummaries")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context_summaries: Option<Vec<ContextSummary>>,
    /// <p>A token for getting the next set of contexts, if there are any.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDataQualityJobDefinitionsRequest {
    /// <p>A filter that returns only data quality monitoring job definitions created after the specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only data quality monitoring job definitions created before the specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>A filter that lists the data quality job definitions associated with the specified endpoint.</p>
    #[serde(rename = "EndpointName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endpoint_name: Option<String>,
    /// <p>The maximum number of data quality monitoring job definitions to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the data quality monitoring job definition name. This filter returns only data quality monitoring job definitions whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of the previous <code>ListDataQualityJobDefinitions</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of transform jobs, use the token in the next request.&gt;</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The field to sort results by. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDataQualityJobDefinitionsResponse {
    /// <p>A list of data quality monitoring job definitions.</p>
    #[serde(rename = "JobDefinitionSummaries")]
    pub job_definition_summaries: Vec<MonitoringJobDefinitionSummary>,
    /// <p>If the result of the previous <code>ListDataQualityJobDefinitions</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of data quality monitoring job definitions, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDeviceFleetsRequest {
    /// <p>Filter fleets where packaging job was created after specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>Filter fleets where the edge packaging job was created before specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>Select fleets where the job was updated after X</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>Select fleets where the job was updated before X</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>The maximum number of results to select.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>Filter for fleets containing this name in their fleet device name.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>The response from the last list when returning a list large enough to need tokening.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The column to sort by.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>What direction to sort in.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDeviceFleetsResponse {
    /// <p>Summary of the device fleet.</p>
    #[serde(rename = "DeviceFleetSummaries")]
    pub device_fleet_summaries: Vec<DeviceFleetSummary>,
    /// <p>The response from the last list when returning a list large enough to need tokening.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDevicesRequest {
    /// <p>Filter for fleets containing this name in their device fleet name.</p>
    #[serde(rename = "DeviceFleetName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub device_fleet_name: Option<String>,
    /// <p>Select fleets where the job was updated after X</p>
    #[serde(rename = "LatestHeartbeatAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latest_heartbeat_after: Option<f64>,
    /// <p>Maximum number of results to select.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A filter that searches devices that contains this name in any of their models.</p>
    #[serde(rename = "ModelName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_name: Option<String>,
    /// <p>The response from the last list when returning a list large enough to need tokening.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDevicesResponse {
    /// <p>Summary of devices.</p>
    #[serde(rename = "DeviceSummaries")]
    pub device_summaries: Vec<DeviceSummary>,
    /// <p>The response from the last list when returning a list large enough to need tokening.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDomainsRequest {
    /// <p>Returns a list up to a specified limit.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the previous response was truncated, you will receive this token. Use it in your next request to receive the next set of results.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDomainsResponse {
    /// <p>The list of domains.</p>
    #[serde(rename = "Domains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domains: Option<Vec<DomainDetails>>,
    /// <p>If the previous response was truncated, you will receive this token. Use it in your next request to receive the next set of results.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListEdgePackagingJobsRequest {
    /// <p>Select jobs where the job was created after specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>Select jobs where the job was created before specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>Select jobs where the job was updated after specified time.</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>Select jobs where the job was updated before specified time.</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>Maximum number of results to select.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>Filter for jobs where the model name contains this string.</p>
    #[serde(rename = "ModelNameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_name_contains: Option<String>,
    /// <p>Filter for jobs containing this name in their packaging job name.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>The response from the last list when returning a list large enough to need tokening.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>Use to specify what column to sort by.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>What direction to sort by.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>The job status to filter for.</p>
    #[serde(rename = "StatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_equals: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListEdgePackagingJobsResponse {
    /// <p>Summaries of edge packaging jobs.</p>
    #[serde(rename = "EdgePackagingJobSummaries")]
    pub edge_packaging_job_summaries: Vec<EdgePackagingJobSummary>,
    /// <p>Token to use when calling the next page of results.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListEndpointConfigsInput {
    /// <p>A filter that returns only endpoint configurations with a creation time greater than or equal to the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only endpoint configurations created before the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>The maximum number of training jobs to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the endpoint configuration name. This filter returns only endpoint configurations whose name contains the specified string. </p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of the previous <code>ListEndpointConfig</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of endpoint configurations, use the token in the next request. </p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The field to sort results by. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListEndpointConfigsOutput {
    /// <p>An array of endpoint configurations.</p>
    #[serde(rename = "EndpointConfigs")]
    pub endpoint_configs: Vec<EndpointConfigSummary>,
    /// <p> If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of endpoint configurations, use it in the subsequent request </p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListEndpointsInput {
    /// <p>A filter that returns only endpoints with a creation time greater than or equal to the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only endpoints that were created before the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p> A filter that returns only endpoints that were modified after the specified timestamp. </p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p> A filter that returns only endpoints that were modified before the specified timestamp. </p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>The maximum number of endpoints to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in endpoint names. This filter returns only endpoints whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of a <code>ListEndpoints</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of endpoints, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>Sorts the list of results. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p> A filter that returns only endpoints with the specified status.</p>
    #[serde(rename = "StatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_equals: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListEndpointsOutput {
    /// <p> An array or endpoint objects. </p>
    #[serde(rename = "Endpoints")]
    pub endpoints: Vec<EndpointSummary>,
    /// <p> If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of training jobs, use it in the subsequent request. </p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListExperimentsRequest {
    /// <p>A filter that returns only experiments created after the specified time.</p>
    #[serde(rename = "CreatedAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_after: Option<f64>,
    /// <p>A filter that returns only experiments created before the specified time.</p>
    #[serde(rename = "CreatedBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_before: Option<f64>,
    /// <p>The maximum number of experiments to return in the response. The default value is 10.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the previous call to <code>ListExperiments</code> didn't return the full set of experiments, the call returns a token for getting the next set of experiments.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The property used to sort results. The default value is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order. The default value is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListExperimentsResponse {
    /// <p>A list of the summaries of your experiments.</p>
    #[serde(rename = "ExperimentSummaries")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_summaries: Option<Vec<ExperimentSummary>>,
    /// <p>A token for getting the next set of experiments, if there are any.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListFeatureGroupsRequest {
    /// <p>Use this parameter to search for <code>FeatureGroups</code>s created after a specific date and time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>Use this parameter to search for <code>FeatureGroups</code>s created before a specific date and time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>A <code>FeatureGroup</code> status. Filters by <code>FeatureGroup</code> status. </p>
    #[serde(rename = "FeatureGroupStatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub feature_group_status_equals: Option<String>,
    /// <p>The maximum number of results returned by <code>ListFeatureGroups</code>.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string that partially matches one or more <code>FeatureGroup</code>s names. Filters <code>FeatureGroup</code>s by name. </p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>A token to resume pagination of <code>ListFeatureGroups</code> results.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>An <code>OfflineStore</code> status. Filters by <code>OfflineStore</code> status. </p>
    #[serde(rename = "OfflineStoreStatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offline_store_status_equals: Option<String>,
    /// <p>The value on which the feature group list is sorted.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The order in which feature groups are listed.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFeatureGroupsResponse {
    /// <p>A summary of feature groups.</p>
    #[serde(rename = "FeatureGroupSummaries")]
    pub feature_group_summaries: Vec<FeatureGroupSummary>,
    /// <p>A token to resume pagination of <code>ListFeatureGroups</code> results.</p>
    #[serde(rename = "NextToken")]
    pub next_token: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListFlowDefinitionsRequest {
    /// <p>A filter that returns only flow definitions with a creation time greater than or equal to the specified timestamp.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only flow definitions that were created before the specified timestamp.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>The total number of items to return. If the total number of available items is more than the value specified in <code>MaxResults</code>, then a <code>NextToken</code> will be provided in the output that you can use to resume pagination.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A token to resume pagination.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>An optional value that specifies whether you want the results sorted in <code>Ascending</code> or <code>Descending</code> order.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFlowDefinitionsResponse {
    /// <p>An array of objects describing the flow definitions.</p>
    #[serde(rename = "FlowDefinitionSummaries")]
    pub flow_definition_summaries: Vec<FlowDefinitionSummary>,
    /// <p>A token to resume pagination.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListHumanTaskUisRequest {
    /// <p>A filter that returns only human task user interfaces with a creation time greater than or equal to the specified timestamp.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only human task user interfaces that were created before the specified timestamp.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>The total number of items to return. If the total number of available items is more than the value specified in <code>MaxResults</code>, then a <code>NextToken</code> will be provided in the output that you can use to resume pagination.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A token to resume pagination.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>An optional value that specifies whether you want the results sorted in <code>Ascending</code> or <code>Descending</code> order.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListHumanTaskUisResponse {
    /// <p>An array of objects describing the human task user interfaces.</p>
    #[serde(rename = "HumanTaskUiSummaries")]
    pub human_task_ui_summaries: Vec<HumanTaskUiSummary>,
    /// <p>A token to resume pagination.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListHyperParameterTuningJobsRequest {
    /// <p>A filter that returns only tuning jobs that were created after the specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only tuning jobs that were created before the specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>A filter that returns only tuning jobs that were modified after the specified time.</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>A filter that returns only tuning jobs that were modified before the specified time.</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>The maximum number of tuning jobs to return. The default value is 10.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the tuning job name. This filter returns only tuning jobs whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of the previous <code>ListHyperParameterTuningJobs</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of tuning jobs, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The field to sort results by. The default is <code>Name</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Ascending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that returns only tuning jobs with the specified status.</p>
    #[serde(rename = "StatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_equals: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListHyperParameterTuningJobsResponse {
    /// <p>A list of <a>HyperParameterTuningJobSummary</a> objects that describe the tuning jobs that the <code>ListHyperParameterTuningJobs</code> request returned.</p>
    #[serde(rename = "HyperParameterTuningJobSummaries")]
    pub hyper_parameter_tuning_job_summaries: Vec<HyperParameterTuningJobSummary>,
    /// <p>If the result of this <code>ListHyperParameterTuningJobs</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of tuning jobs, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListImageVersionsRequest {
    /// <p>A filter that returns only versions created on or after the specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only versions created on or before the specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>The name of the image to list the versions of.</p>
    #[serde(rename = "ImageName")]
    pub image_name: String,
    /// <p>A filter that returns only versions modified on or after the specified time.</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>A filter that returns only versions modified on or before the specified time.</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>The maximum number of versions to return in the response. The default value is 10. </p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the previous call to <code>ListImageVersions</code> didn't return the full set of versions, the call returns a token for getting the next set of versions.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The property used to sort results. The default value is <code>CREATION_TIME</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order. The default value is <code>DESCENDING</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListImageVersionsResponse {
    /// <p>A list of versions and their properties.</p>
    #[serde(rename = "ImageVersions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_versions: Option<Vec<ImageVersion>>,
    /// <p>A token for getting the next set of versions, if there are any.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListImagesRequest {
    /// <p>A filter that returns only images created on or after the specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only images created on or before the specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>A filter that returns only images modified on or after the specified time.</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>A filter that returns only images modified on or before the specified time.</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>The maximum number of images to return in the response. The default value is 10. </p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A filter that returns only images whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the previous call to <code>ListImages</code> didn't return the full set of images, the call returns a token for getting the next set of images.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The property used to sort results. The default value is <code>CREATION_TIME</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order. The default value is <code>DESCENDING</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListImagesResponse {
    /// <p>A list of images and their properties.</p>
    #[serde(rename = "Images")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub images: Option<Vec<Image>>,
    /// <p>A token for getting the next set of images, if there are any.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListLabelingJobsForWorkteamRequest {
    /// <p>A filter that returns only labeling jobs created after the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only labeling jobs created before the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>A filter the limits jobs to only the ones whose job reference code contains the specified string.</p>
    #[serde(rename = "JobReferenceCodeContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub job_reference_code_contains: Option<String>,
    /// <p>The maximum number of labeling jobs to return in each page of the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the result of the previous <code>ListLabelingJobsForWorkteam</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of labeling jobs, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The field to sort results by. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Ascending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the work team for which you want to see labeling jobs for.</p>
    #[serde(rename = "WorkteamArn")]
    pub workteam_arn: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListLabelingJobsForWorkteamResponse {
    /// <p>An array of <code>LabelingJobSummary</code> objects, each describing a labeling job.</p>
    #[serde(rename = "LabelingJobSummaryList")]
    pub labeling_job_summary_list: Vec<LabelingJobForWorkteamSummary>,
    /// <p>If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of labeling jobs, use it in the subsequent request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListLabelingJobsRequest {
    /// <p>A filter that returns only labeling jobs created after the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only labeling jobs created before the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>A filter that returns only labeling jobs modified after the specified time (timestamp).</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>A filter that returns only labeling jobs modified before the specified time (timestamp).</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>The maximum number of labeling jobs to return in each page of the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the labeling job name. This filter returns only labeling jobs whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of the previous <code>ListLabelingJobs</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of labeling jobs, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The field to sort results by. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Ascending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that retrieves only labeling jobs with a specific status.</p>
    #[serde(rename = "StatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_equals: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListLabelingJobsResponse {
    /// <p>An array of <code>LabelingJobSummary</code> objects, each describing a labeling job.</p>
    #[serde(rename = "LabelingJobSummaryList")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub labeling_job_summary_list: Option<Vec<LabelingJobSummary>>,
    /// <p>If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of labeling jobs, use it in the subsequent request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListModelBiasJobDefinitionsRequest {
    /// <p>A filter that returns only model bias jobs created after a specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only model bias jobs created before a specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>Name of the endpoint to monitor for model bias.</p>
    #[serde(rename = "EndpointName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endpoint_name: Option<String>,
    /// <p>The maximum number of model bias jobs to return in the response. The default value is 10.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>Filter for model bias jobs whose name contains a specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>The token returned if the response is truncated. To retrieve the next set of job executions, use it in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>Whether to sort results by the <code>Name</code> or <code>CreationTime</code> field. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>Whether to sort the results in <code>Ascending</code> or <code>Descending</code> order. The default is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListModelBiasJobDefinitionsResponse {
    /// <p>A JSON array in which each element is a summary for a model bias jobs.</p>
    #[serde(rename = "JobDefinitionSummaries")]
    pub job_definition_summaries: Vec<MonitoringJobDefinitionSummary>,
    /// <p>If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of jobs, use it in the subsequent request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListModelExplainabilityJobDefinitionsRequest {
    /// <p>A filter that returns only model explainability jobs created after a specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only model explainability jobs created before a specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>Name of the endpoint to monitor for model explainability.</p>
    #[serde(rename = "EndpointName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endpoint_name: Option<String>,
    /// <p>The maximum number of jobs to return in the response. The default value is 10.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>Filter for model explainability jobs whose name contains a specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>The token returned if the response is truncated. To retrieve the next set of job executions, use it in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>Whether to sort results by the <code>Name</code> or <code>CreationTime</code> field. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>Whether to sort the results in <code>Ascending</code> or <code>Descending</code> order. The default is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListModelExplainabilityJobDefinitionsResponse {
    /// <p>A JSON array in which each element is a summary for a explainability bias jobs.</p>
    #[serde(rename = "JobDefinitionSummaries")]
    pub job_definition_summaries: Vec<MonitoringJobDefinitionSummary>,
    /// <p>If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of jobs, use it in the subsequent request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListModelPackageGroupsInput {
    /// <p>A filter that returns only model groups created after the specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only model groups created before the specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>The maximum number of results to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the model group name. This filter returns only model groups whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of the previous <code>ListModelPackageGroups</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of model groups, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The field to sort results by. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Ascending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListModelPackageGroupsOutput {
    /// <p>A list of summaries of the model groups in your AWS account.</p>
    #[serde(rename = "ModelPackageGroupSummaryList")]
    pub model_package_group_summary_list: Vec<ModelPackageGroupSummary>,
    /// <p>If the response is truncated, SageMaker returns this token. To retrieve the next set of model groups, use it in the subsequent request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListModelPackagesInput {
    /// <p>A filter that returns only model packages created after the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only model packages created before the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>The maximum number of model packages to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A filter that returns only the model packages with the specified approval status.</p>
    #[serde(rename = "ModelApprovalStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_approval_status: Option<String>,
    /// <p>A filter that returns only model versions that belong to the specified model group.</p>
    #[serde(rename = "ModelPackageGroupName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_group_name: Option<String>,
    /// <p><p>A filter that returns onlyl the model packages of the specified type. This can be one of the following values.</p> <ul> <li> <p> <code>VERSIONED</code> - List only versioned models.</p> </li> <li> <p> <code>UNVERSIONED</code> - List only unversioined models.</p> </li> <li> <p> <code>BOTH</code> - List both versioned and unversioned models.</p> </li> </ul></p>
    #[serde(rename = "ModelPackageType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_type: Option<String>,
    /// <p>A string in the model package name. This filter returns only model packages whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the response to a previous <code>ListModelPackages</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of model packages, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The parameter by which to sort the results. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for the results. The default is <code>Ascending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListModelPackagesOutput {
    /// <p>An array of <code>ModelPackageSummary</code> objects, each of which lists a model package.</p>
    #[serde(rename = "ModelPackageSummaryList")]
    pub model_package_summary_list: Vec<ModelPackageSummary>,
    /// <p>If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of model packages, use it in the subsequent request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListModelQualityJobDefinitionsRequest {
    /// <p>A filter that returns only model quality monitoring job definitions created after the specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only model quality monitoring job definitions created before the specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>A filter that returns only model quality monitoring job definitions that are associated with the specified endpoint.</p>
    #[serde(rename = "EndpointName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endpoint_name: Option<String>,
    /// <p>The maximum number of results to return in a call to <code>ListModelQualityJobDefinitions</code>.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the transform job name. This filter returns only model quality monitoring job definitions whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of the previous <code>ListModelQualityJobDefinitions</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of model quality monitoring job definitions, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The field to sort results by. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListModelQualityJobDefinitionsResponse {
    /// <p>A list of summaries of model quality monitoring job definitions.</p>
    #[serde(rename = "JobDefinitionSummaries")]
    pub job_definition_summaries: Vec<MonitoringJobDefinitionSummary>,
    /// <p>If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of model quality monitoring job definitions, use it in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListModelsInput {
    /// <p>A filter that returns only models with a creation time greater than or equal to the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only models created before the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>The maximum number of models to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the training job name. This filter returns only models in the training job whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the response to a previous <code>ListModels</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of models, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>Sorts the list of results. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListModelsOutput {
    /// <p>An array of <code>ModelSummary</code> objects, each of which lists a model.</p>
    #[serde(rename = "Models")]
    pub models: Vec<ModelSummary>,
    /// <p> If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of models, use it in the subsequent request. </p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListMonitoringExecutionsRequest {
    /// <p>A filter that returns only jobs created after a specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only jobs created before a specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>Name of a specific endpoint to fetch jobs for.</p>
    #[serde(rename = "EndpointName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endpoint_name: Option<String>,
    /// <p>A filter that returns only jobs modified before a specified time.</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>A filter that returns only jobs modified after a specified time.</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>The maximum number of jobs to return in the response. The default value is 10.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>Gets a list of the monitoring job runs of the specified monitoring job definitions.</p>
    #[serde(rename = "MonitoringJobDefinitionName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_job_definition_name: Option<String>,
    /// <p>Name of a specific schedule to fetch jobs for.</p>
    #[serde(rename = "MonitoringScheduleName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_schedule_name: Option<String>,
    /// <p>A filter that returns only the monitoring job runs of the specified monitoring type.</p>
    #[serde(rename = "MonitoringTypeEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_type_equals: Option<String>,
    /// <p>The token returned if the response is truncated. To retrieve the next set of job executions, use it in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>Filter for jobs scheduled after a specified time.</p>
    #[serde(rename = "ScheduledTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub scheduled_time_after: Option<f64>,
    /// <p>Filter for jobs scheduled before a specified time.</p>
    #[serde(rename = "ScheduledTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub scheduled_time_before: Option<f64>,
    /// <p>Whether to sort results by <code>Status</code>, <code>CreationTime</code>, <code>ScheduledTime</code> field. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>Whether to sort the results in <code>Ascending</code> or <code>Descending</code> order. The default is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that retrieves only jobs with a specific status.</p>
    #[serde(rename = "StatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_equals: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListMonitoringExecutionsResponse {
    /// <p>A JSON array in which each element is a summary for a monitoring execution.</p>
    #[serde(rename = "MonitoringExecutionSummaries")]
    pub monitoring_execution_summaries: Vec<MonitoringExecutionSummary>,
    /// <p>If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of jobs, use it in the subsequent reques</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListMonitoringSchedulesRequest {
    /// <p>A filter that returns only monitoring schedules created after a specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only monitoring schedules created before a specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>Name of a specific endpoint to fetch schedules for.</p>
    #[serde(rename = "EndpointName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endpoint_name: Option<String>,
    /// <p>A filter that returns only monitoring schedules modified after a specified time.</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>A filter that returns only monitoring schedules modified before a specified time.</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>The maximum number of jobs to return in the response. The default value is 10.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>Gets a list of the monitoring schedules for the specified monitoring job definition.</p>
    #[serde(rename = "MonitoringJobDefinitionName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_job_definition_name: Option<String>,
    /// <p>A filter that returns only the monitoring schedules for the specified monitoring type.</p>
    #[serde(rename = "MonitoringTypeEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_type_equals: Option<String>,
    /// <p>Filter for monitoring schedules whose name contains a specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>The token returned if the response is truncated. To retrieve the next set of job executions, use it in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>Whether to sort results by <code>Status</code>, <code>CreationTime</code>, <code>ScheduledTime</code> field. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>Whether to sort the results in <code>Ascending</code> or <code>Descending</code> order. The default is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that returns only monitoring schedules modified before a specified time.</p>
    #[serde(rename = "StatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_equals: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListMonitoringSchedulesResponse {
    /// <p>A JSON array in which each element is a summary for a monitoring schedule.</p>
    #[serde(rename = "MonitoringScheduleSummaries")]
    pub monitoring_schedule_summaries: Vec<MonitoringScheduleSummary>,
    /// <p>If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of jobs, use it in the subsequent request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListNotebookInstanceLifecycleConfigsInput {
    /// <p>A filter that returns only lifecycle configurations that were created after the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only lifecycle configurations that were created before the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>A filter that returns only lifecycle configurations that were modified after the specified time (timestamp).</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>A filter that returns only lifecycle configurations that were modified before the specified time (timestamp).</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>The maximum number of lifecycle configurations to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the lifecycle configuration name. This filter returns only lifecycle configurations whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of a <code>ListNotebookInstanceLifecycleConfigs</code> request was truncated, the response includes a <code>NextToken</code>. To get the next set of lifecycle configurations, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>Sorts the list of results. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListNotebookInstanceLifecycleConfigsOutput {
    /// <p>If the response is truncated, Amazon SageMaker returns this token. To get the next set of lifecycle configurations, use it in the next request. </p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>An array of <code>NotebookInstanceLifecycleConfiguration</code> objects, each listing a lifecycle configuration.</p>
    #[serde(rename = "NotebookInstanceLifecycleConfigs")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_instance_lifecycle_configs: Option<Vec<NotebookInstanceLifecycleConfigSummary>>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListNotebookInstancesInput {
    /// <p>A filter that returns only notebook instances with associated with the specified git repository.</p>
    #[serde(rename = "AdditionalCodeRepositoryEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub additional_code_repository_equals: Option<String>,
    /// <p>A filter that returns only notebook instances that were created after the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only notebook instances that were created before the specified time (timestamp). </p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>A string in the name or URL of a Git repository associated with this notebook instance. This filter returns only notebook instances associated with a git repository with a name that contains the specified string.</p>
    #[serde(rename = "DefaultCodeRepositoryContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_code_repository_contains: Option<String>,
    /// <p>A filter that returns only notebook instances that were modified after the specified time (timestamp).</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>A filter that returns only notebook instances that were modified before the specified time (timestamp).</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>The maximum number of notebook instances to return.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the notebook instances' name. This filter returns only notebook instances whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p><p> If the previous call to the <code>ListNotebookInstances</code> is truncated, the response includes a <code>NextToken</code>. You can use this token in your subsequent <code>ListNotebookInstances</code> request to fetch the next set of notebook instances. </p> <note> <p>You might specify a filter or a sort order in your request. When response is truncated, you must use the same values for the filer and sort order in the next request. </p> </note></p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>A string in the name of a notebook instances lifecycle configuration associated with this notebook instance. This filter returns only notebook instances associated with a lifecycle configuration with a name that contains the specified string.</p>
    #[serde(rename = "NotebookInstanceLifecycleConfigNameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_instance_lifecycle_config_name_contains: Option<String>,
    /// <p>The field to sort results by. The default is <code>Name</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. </p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that returns only notebook instances with the specified status.</p>
    #[serde(rename = "StatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_equals: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListNotebookInstancesOutput {
    /// <p>If the response to the previous <code>ListNotebookInstances</code> request was truncated, Amazon SageMaker returns this token. To retrieve the next set of notebook instances, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>An array of <code>NotebookInstanceSummary</code> objects, one for each notebook instance.</p>
    #[serde(rename = "NotebookInstances")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_instances: Option<Vec<NotebookInstanceSummary>>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPipelineExecutionStepsRequest {
    /// <p>The maximum number of pipeline execution steps to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the result of the previous <code>ListPipelineExecutionSteps</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of pipeline execution steps, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_arn: Option<String>,
    /// <p>The field by which to sort results. The default is <code>CreatedTime</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPipelineExecutionStepsResponse {
    /// <p>If the result of the previous <code>ListPipelineExecutionSteps</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of pipeline execution steps, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>A list of <code>PipeLineExecutionStep</code> objects. Each <code>PipeLineExecutionStep</code> consists of StepName, StartTime, EndTime, StepStatus, and Metadata. Metadata is an object with properties for each job that contains relevant information about the job created by the step.</p>
    #[serde(rename = "PipelineExecutionSteps")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_steps: Option<Vec<PipelineExecutionStep>>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPipelineExecutionsRequest {
    /// <p>A filter that returns the pipeline executions that were created after a specified time.</p>
    #[serde(rename = "CreatedAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_after: Option<f64>,
    /// <p>A filter that returns the pipeline executions that were created before a specified time.</p>
    #[serde(rename = "CreatedBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_before: Option<f64>,
    /// <p>The maximum number of pipeline executions to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the result of the previous <code>ListPipelineExecutions</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of pipeline executions, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The name of the pipeline.</p>
    #[serde(rename = "PipelineName")]
    pub pipeline_name: String,
    /// <p>The field by which to sort results. The default is <code>CreatedTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPipelineExecutionsResponse {
    /// <p>If the result of the previous <code>ListPipelineExecutions</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of pipeline executions, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>Contains a sorted list of pipeline execution summary objects matching the specified filters. Each run summary includes the Amazon Resource Name (ARN) of the pipeline execution, the run date, and the status. This list can be empty. </p>
    #[serde(rename = "PipelineExecutionSummaries")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_summaries: Option<Vec<PipelineExecutionSummary>>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPipelineParametersForExecutionRequest {
    /// <p>The maximum number of parameters to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the result of the previous <code>ListPipelineParametersForExecution</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of parameters, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionArn")]
    pub pipeline_execution_arn: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPipelineParametersForExecutionResponse {
    /// <p>If the result of the previous <code>ListPipelineParametersForExecution</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of parameters, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>Contains a list of pipeline parameters. This list can be empty. </p>
    #[serde(rename = "PipelineParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_parameters: Option<Vec<Parameter>>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPipelinesRequest {
    /// <p>A filter that returns the pipelines that were created after a specified time.</p>
    #[serde(rename = "CreatedAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_after: Option<f64>,
    /// <p>A filter that returns the pipelines that were created before a specified time.</p>
    #[serde(rename = "CreatedBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_before: Option<f64>,
    /// <p>The maximum number of pipelines to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the result of the previous <code>ListPipelines</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of pipelines, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The prefix of the pipeline name.</p>
    #[serde(rename = "PipelineNamePrefix")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_name_prefix: Option<String>,
    /// <p>The field by which to sort results. The default is <code>CreatedTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPipelinesResponse {
    /// <p>If the result of the previous <code>ListPipelines</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of pipelines, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>Contains a sorted list of <code>PipelineSummary</code> objects matching the specified filters. Each <code>PipelineSummary</code> consists of PipelineArn, PipelineName, ExperimentName, PipelineDescription, CreationTime, LastModifiedTime, LastRunTime, and RoleArn. This list can be empty. </p>
    #[serde(rename = "PipelineSummaries")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_summaries: Option<Vec<PipelineSummary>>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListProcessingJobsRequest {
    /// <p>A filter that returns only processing jobs created after the specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only processing jobs created after the specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>A filter that returns only processing jobs modified after the specified time.</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>A filter that returns only processing jobs modified before the specified time.</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>The maximum number of processing jobs to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the processing job name. This filter returns only processing jobs whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of the previous <code>ListProcessingJobs</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of processing jobs, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The field to sort results by. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Ascending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that retrieves only processing jobs with a specific status.</p>
    #[serde(rename = "StatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_equals: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListProcessingJobsResponse {
    /// <p>If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of processing jobs, use it in the subsequent request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>An array of <code>ProcessingJobSummary</code> objects, each listing a processing job.</p>
    #[serde(rename = "ProcessingJobSummaries")]
    pub processing_job_summaries: Vec<ProcessingJobSummary>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListProjectsInput {
    /// <p>A filter that returns the projects that were created after a specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns the projects that were created before a specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>The maximum number of projects to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A filter that returns the projects whose name contains a specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of the previous <code>ListProjects</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of projects, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The field by which to sort results. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Ascending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListProjectsOutput {
    /// <p>If the result of the previous <code>ListCompilationJobs</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of model compilation jobs, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>A list of summaries of projects.</p>
    #[serde(rename = "ProjectSummaryList")]
    pub project_summary_list: Vec<ProjectSummary>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListSubscribedWorkteamsRequest {
    /// <p>The maximum number of work teams to return in each page of the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the work team name. This filter returns only work teams whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of the previous <code>ListSubscribedWorkteams</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of labeling jobs, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListSubscribedWorkteamsResponse {
    /// <p>If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of work teams, use it in the subsequent request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>An array of <code>Workteam</code> objects, each describing a work team.</p>
    #[serde(rename = "SubscribedWorkteams")]
    pub subscribed_workteams: Vec<SubscribedWorkteam>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsInput {
    /// <p>Maximum number of tags to return.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p> If the response to the previous <code>ListTags</code> request is truncated, Amazon SageMaker returns this token. To retrieve the next set of tags, use it in the subsequent request. </p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the resource whose tags you want to retrieve.</p>
    #[serde(rename = "ResourceArn")]
    pub resource_arn: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsOutput {
    /// <p> If response is truncated, Amazon SageMaker includes a token in the response. You can use this token in your subsequent request to fetch next set of tokens. </p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>An array of <code>Tag</code> objects, each with a tag key and a value.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTrainingJobsForHyperParameterTuningJobRequest {
    /// <p>The name of the tuning job whose training jobs you want to list.</p>
    #[serde(rename = "HyperParameterTuningJobName")]
    pub hyper_parameter_tuning_job_name: String,
    /// <p>The maximum number of training jobs to return. The default value is 10.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the result of the previous <code>ListTrainingJobsForHyperParameterTuningJob</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of training jobs, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The field to sort results by. The default is <code>Name</code>.</p> <p>If the value of this field is <code>FinalObjectiveMetricValue</code>, any training jobs that did not return an objective metric are not listed.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Ascending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that returns only training jobs with the specified status.</p>
    #[serde(rename = "StatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_equals: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTrainingJobsForHyperParameterTuningJobResponse {
    /// <p>If the result of this <code>ListTrainingJobsForHyperParameterTuningJob</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of training jobs, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>A list of <a>TrainingJobSummary</a> objects that describe the training jobs that the <code>ListTrainingJobsForHyperParameterTuningJob</code> request returned.</p>
    #[serde(rename = "TrainingJobSummaries")]
    pub training_job_summaries: Vec<HyperParameterTrainingJobSummary>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTrainingJobsRequest {
    /// <p>A filter that returns only training jobs created after the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only training jobs created before the specified time (timestamp).</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>A filter that returns only training jobs modified after the specified time (timestamp).</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>A filter that returns only training jobs modified before the specified time (timestamp).</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>The maximum number of training jobs to return in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the training job name. This filter returns only training jobs whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of the previous <code>ListTrainingJobs</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of training jobs, use the token in the next request. </p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The field to sort results by. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Ascending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that retrieves only training jobs with a specific status.</p>
    #[serde(rename = "StatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_equals: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTrainingJobsResponse {
    /// <p>If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of training jobs, use it in the subsequent request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>An array of <code>TrainingJobSummary</code> objects, each listing a training job.</p>
    #[serde(rename = "TrainingJobSummaries")]
    pub training_job_summaries: Vec<TrainingJobSummary>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTransformJobsRequest {
    /// <p>A filter that returns only transform jobs created after the specified time.</p>
    #[serde(rename = "CreationTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_after: Option<f64>,
    /// <p>A filter that returns only transform jobs created before the specified time.</p>
    #[serde(rename = "CreationTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time_before: Option<f64>,
    /// <p>A filter that returns only transform jobs modified after the specified time.</p>
    #[serde(rename = "LastModifiedTimeAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_after: Option<f64>,
    /// <p>A filter that returns only transform jobs modified before the specified time.</p>
    #[serde(rename = "LastModifiedTimeBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time_before: Option<f64>,
    /// <p>The maximum number of transform jobs to return in the response. The default value is <code>10</code>.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the transform job name. This filter returns only transform jobs whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of the previous <code>ListTransformJobs</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of transform jobs, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The field to sort results by. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that retrieves only transform jobs with a specific status.</p>
    #[serde(rename = "StatusEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_equals: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTransformJobsResponse {
    /// <p>If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of transform jobs, use it in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>An array of <code>TransformJobSummary</code> objects.</p>
    #[serde(rename = "TransformJobSummaries")]
    pub transform_job_summaries: Vec<TransformJobSummary>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTrialComponentsRequest {
    /// <p>A filter that returns only components created after the specified time.</p>
    #[serde(rename = "CreatedAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_after: Option<f64>,
    /// <p>A filter that returns only components created before the specified time.</p>
    #[serde(rename = "CreatedBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_before: Option<f64>,
    /// <p>A filter that returns only components that are part of the specified experiment. If you specify <code>ExperimentName</code>, you can't filter by <code>SourceArn</code> or <code>TrialName</code>.</p>
    #[serde(rename = "ExperimentName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_name: Option<String>,
    /// <p>The maximum number of components to return in the response. The default value is 10.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the previous call to <code>ListTrialComponents</code> didn't return the full set of components, the call returns a token for getting the next set of components.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The property used to sort results. The default value is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order. The default value is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that returns only components that have the specified source Amazon Resource Name (ARN). If you specify <code>SourceArn</code>, you can't filter by <code>ExperimentName</code> or <code>TrialName</code>.</p>
    #[serde(rename = "SourceArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_arn: Option<String>,
    /// <p>A filter that returns only components that are part of the specified trial. If you specify <code>TrialName</code>, you can't filter by <code>ExperimentName</code> or <code>SourceArn</code>.</p>
    #[serde(rename = "TrialName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_name: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTrialComponentsResponse {
    /// <p>A token for getting the next set of components, if there are any.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>A list of the summaries of your trial components.</p>
    #[serde(rename = "TrialComponentSummaries")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_summaries: Option<Vec<TrialComponentSummary>>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTrialsRequest {
    /// <p>A filter that returns only trials created after the specified time.</p>
    #[serde(rename = "CreatedAfter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_after: Option<f64>,
    /// <p>A filter that returns only trials created before the specified time.</p>
    #[serde(rename = "CreatedBefore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_before: Option<f64>,
    /// <p>A filter that returns only trials that are part of the specified experiment.</p>
    #[serde(rename = "ExperimentName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_name: Option<String>,
    /// <p>The maximum number of trials to return in the response. The default value is 10.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the previous call to <code>ListTrials</code> didn't return the full set of trials, the call returns a token for getting the next set of trials.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The property used to sort results. The default value is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order. The default value is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A filter that returns only trials that are associated with the specified trial component.</p>
    #[serde(rename = "TrialComponentName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_name: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTrialsResponse {
    /// <p>A token for getting the next set of trials, if there are any.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>A list of the summaries of your trials.</p>
    #[serde(rename = "TrialSummaries")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_summaries: Option<Vec<TrialSummary>>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListUserProfilesRequest {
    /// <p>A parameter by which to filter the results.</p>
    #[serde(rename = "DomainIdEquals")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_id_equals: Option<String>,
    /// <p>Returns a list up to a specified limit.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If the previous response was truncated, you will receive this token. Use it in your next request to receive the next set of results.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The parameter by which to sort the results. The default is CreationTime.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for the results. The default is Ascending.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
    /// <p>A parameter by which to filter the results.</p>
    #[serde(rename = "UserProfileNameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_profile_name_contains: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListUserProfilesResponse {
    /// <p>If the previous response was truncated, you will receive this token. Use it in your next request to receive the next set of results.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The list of user profiles.</p>
    #[serde(rename = "UserProfiles")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_profiles: Option<Vec<UserProfileDetails>>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListWorkforcesRequest {
    /// <p>The maximum number of workforces returned in the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A filter you can use to search for workforces using part of the workforce name.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>A token to resume pagination.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>Sort workforces using the workforce name or creation date.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>Sort workforces in ascending or descending order.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListWorkforcesResponse {
    /// <p>A token to resume pagination.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>A list containing information about your workforce.</p>
    #[serde(rename = "Workforces")]
    pub workforces: Vec<Workforce>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListWorkteamsRequest {
    /// <p>The maximum number of work teams to return in each page of the response.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>A string in the work team's name. This filter returns only work teams whose name contains the specified string.</p>
    #[serde(rename = "NameContains")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_contains: Option<String>,
    /// <p>If the result of the previous <code>ListWorkteams</code> request was truncated, the response includes a <code>NextToken</code>. To retrieve the next set of labeling jobs, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The field to sort results by. The default is <code>CreationTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>The sort order for results. The default is <code>Ascending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListWorkteamsResponse {
    /// <p>If the response is truncated, Amazon SageMaker returns this token. To retrieve the next set of work teams, use it in the subsequent request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>An array of <code>Workteam</code> objects, each describing a work team.</p>
    #[serde(rename = "Workteams")]
    pub workteams: Vec<Workteam>,
}

/// <p>Defines an Amazon Cognito or your own OIDC IdP user group that is part of a work team.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MemberDefinition {
    /// <p>The Amazon Cognito user group that is part of the work team.</p>
    #[serde(rename = "CognitoMemberDefinition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cognito_member_definition: Option<CognitoMemberDefinition>,
    /// <p>A list 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 <code>Groups</code>, 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.</p>
    #[serde(rename = "OidcMemberDefinition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub oidc_member_definition: Option<OidcMemberDefinition>,
}

/// <p>Metadata properties of the tracking entity, trial, or trial component.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MetadataProperties {
    /// <p>The commit ID.</p>
    #[serde(rename = "CommitId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub commit_id: Option<String>,
    /// <p>The entity this entity was generated by.</p>
    #[serde(rename = "GeneratedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub generated_by: Option<String>,
    /// <p>The project ID.</p>
    #[serde(rename = "ProjectId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub project_id: Option<String>,
    /// <p>The repository.</p>
    #[serde(rename = "Repository")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub repository: Option<String>,
}

/// <p>The name, value, and date and time of a metric that was emitted to Amazon CloudWatch.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MetricData {
    /// <p>The name of the metric.</p>
    #[serde(rename = "MetricName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metric_name: Option<String>,
    /// <p>The date and time that the algorithm emitted the metric.</p>
    #[serde(rename = "Timestamp")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<f64>,
    /// <p>The value of the metric.</p>
    #[serde(rename = "Value")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub value: Option<f32>,
}

/// <p>Specifies a metric that the training algorithm writes to <code>stderr</code> or <code>stdout</code> . Amazon SageMakerhyperparameter tuning captures all defined metrics. You specify one metric that a hyperparameter tuning job uses as its objective metric to choose the best training job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MetricDefinition {
    /// <p>The name of the metric.</p>
    #[serde(rename = "Name")]
    pub name: String,
    /// <p>A regular expression that searches the output of a training job and gets the value of the metric. For more information about using regular expressions to define metrics, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-define-metrics.html">Defining Objective Metrics</a>.</p>
    #[serde(rename = "Regex")]
    pub regex: String,
}

/// <p><p/></p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MetricsSource {
    /// <p><p/></p>
    #[serde(rename = "ContentDigest")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content_digest: Option<String>,
    /// <p><p/></p>
    #[serde(rename = "ContentType")]
    pub content_type: String,
    /// <p><p/></p>
    #[serde(rename = "S3Uri")]
    pub s3_uri: String,
}

/// <p>Provides information about the location that is configured for storing model artifacts. </p> <p>Model artifacts are the output that results from training a model, and typically consist of trained parameters, a model defintion that desribes how to compute inferences, and other metadata.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModelArtifacts {
    /// <p>The path of the S3 object that contains the model artifacts. For example, <code>s3://bucket-name/keynameprefix/model.tar.gz</code>.</p>
    #[serde(rename = "S3ModelArtifacts")]
    pub s3_model_artifacts: String,
}

/// <p>Docker container image configuration object for the model bias job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelBiasAppSpecification {
    /// <p>JSON formatted S3 file that defines bias parameters. For more information on this JSON configuration file, see <a href="https://docs.aws.amazon.com/sagemaker/latest/json-bias-parameter-config.html">Configure bias parameters</a>.</p>
    #[serde(rename = "ConfigUri")]
    pub config_uri: String,
    /// <p>Sets the environment variables in the Docker container.</p>
    #[serde(rename = "Environment")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub environment: Option<::std::collections::HashMap<String, String>>,
    /// <p>The container image to be run by the model bias job.</p>
    #[serde(rename = "ImageUri")]
    pub image_uri: String,
}

/// <p>The configuration for a baseline model bias job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelBiasBaselineConfig {
    /// <p>The name of the baseline model bias job.</p>
    #[serde(rename = "BaseliningJobName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub baselining_job_name: Option<String>,
    #[serde(rename = "ConstraintsResource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub constraints_resource: Option<MonitoringConstraintsResource>,
}

/// <p>Inputs for the model bias job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelBiasJobInput {
    #[serde(rename = "EndpointInput")]
    pub endpoint_input: EndpointInput,
    /// <p>Location of ground truth labels to use in model bias job.</p>
    #[serde(rename = "GroundTruthS3Input")]
    pub ground_truth_s3_input: MonitoringGroundTruthS3Input,
}

/// <p>Configures the timeout and maximum number of retries for processing a transform job invocation.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelClientConfig {
    /// <p>The maximum number of retries when invocation requests are failing.</p>
    #[serde(rename = "InvocationsMaxRetries")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub invocations_max_retries: Option<i64>,
    /// <p>The timeout value in seconds for an invocation request.</p>
    #[serde(rename = "InvocationsTimeoutInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub invocations_timeout_in_seconds: Option<i64>,
}

/// <p>Data quality constraints and statistics for a model.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelDataQuality {
    /// <p>Data quality constraints for a model.</p>
    #[serde(rename = "Constraints")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub constraints: Option<MetricsSource>,
    /// <p>Data quality statistics for a model.</p>
    #[serde(rename = "Statistics")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub statistics: Option<MetricsSource>,
}

/// <p>Provides information to verify the integrity of stored model artifacts. </p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModelDigests {
    /// <p>Provides a hash value that uniquely identifies the stored model artifacts.</p>
    #[serde(rename = "ArtifactDigest")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artifact_digest: Option<String>,
}

/// <p>Docker container image configuration object for the model explainability job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelExplainabilityAppSpecification {
    /// <p>JSON formatted S3 file that defines explainability parameters. For more information on this JSON configuration file, see <a href="https://docs.aws.amazon.com/sagemaker/latest/json-model-explainability-parameter-config.html">Configure model explainability parameters</a>.</p>
    #[serde(rename = "ConfigUri")]
    pub config_uri: String,
    /// <p>Sets the environment variables in the Docker container.</p>
    #[serde(rename = "Environment")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub environment: Option<::std::collections::HashMap<String, String>>,
    /// <p>The container image to be run by the model explainability job.</p>
    #[serde(rename = "ImageUri")]
    pub image_uri: String,
}

/// <p>The configuration for a baseline model explainability job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelExplainabilityBaselineConfig {
    /// <p>The name of the baseline model explainability job.</p>
    #[serde(rename = "BaseliningJobName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub baselining_job_name: Option<String>,
    #[serde(rename = "ConstraintsResource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub constraints_resource: Option<MonitoringConstraintsResource>,
}

/// <p>Inputs for the model explainability job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelExplainabilityJobInput {
    #[serde(rename = "EndpointInput")]
    pub endpoint_input: EndpointInput,
}

/// <p>Contains metrics captured from a model.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelMetrics {
    /// <p>Metrics that measure bais in a model.</p>
    #[serde(rename = "Bias")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub bias: Option<Bias>,
    /// <p>Metrics that help explain a model.</p>
    #[serde(rename = "Explainability")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub explainability: Option<Explainability>,
    /// <p>Metrics that measure the quality of the input data for a model.</p>
    #[serde(rename = "ModelDataQuality")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_data_quality: Option<ModelDataQuality>,
    /// <p>Metrics that measure the quality of a model.</p>
    #[serde(rename = "ModelQuality")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_quality: Option<ModelQuality>,
}

/// <p>A versioned model that can be deployed for SageMaker inference.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModelPackage {
    /// <p>A description provided when the model approval is set.</p>
    #[serde(rename = "ApprovalDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub approval_description: Option<String>,
    /// <p>Whether the model package is to be certified to be listed on AWS Marketplace. For information about listing model packages on AWS Marketplace, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-mkt-list.html">List Your Algorithm or Model Package on AWS Marketplace</a>.</p>
    #[serde(rename = "CertifyForMarketplace")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub certify_for_marketplace: Option<bool>,
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>The time that the model package was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    #[serde(rename = "InferenceSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inference_specification: Option<InferenceSpecification>,
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>The last time the model package was modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    #[serde(rename = "MetadataProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_properties: Option<MetadataProperties>,
    /// <p><p>The approval status of the model. This can be one of the following values.</p> <ul> <li> <p> <code>APPROVED</code> - The model is approved</p> </li> <li> <p> <code>REJECTED</code> - The model is rejected.</p> </li> <li> <p> <code>PENDING<em>MANUAL</em>APPROVAL</code> - The model is waiting for manual approval.</p> </li> </ul></p>
    #[serde(rename = "ModelApprovalStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_approval_status: Option<String>,
    /// <p>Metrics for the model.</p>
    #[serde(rename = "ModelMetrics")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_metrics: Option<ModelMetrics>,
    /// <p>The Amazon Resource Name (ARN) of the model package.</p>
    #[serde(rename = "ModelPackageArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_arn: Option<String>,
    /// <p>The description of the model package.</p>
    #[serde(rename = "ModelPackageDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_description: Option<String>,
    /// <p>The model group to which the model belongs.</p>
    #[serde(rename = "ModelPackageGroupName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_group_name: Option<String>,
    /// <p>The name of the model.</p>
    #[serde(rename = "ModelPackageName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_name: Option<String>,
    /// <p><p>The status of the model package. This can be one of the following values.</p> <ul> <li> <p> <code>PENDING</code> - The model package is pending being created.</p> </li> <li> <p> <code>IN_PROGRESS</code> - The model package is in the process of being created.</p> </li> <li> <p> <code>COMPLETED</code> - The model package was successfully created.</p> </li> <li> <p> <code>FAILED</code> - The model package failed.</p> </li> <li> <p> <code>DELETING</code> - The model package is in the process of being deleted.</p> </li> </ul></p>
    #[serde(rename = "ModelPackageStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_status: Option<String>,
    #[serde(rename = "ModelPackageStatusDetails")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_status_details: Option<ModelPackageStatusDetails>,
    /// <p>The version number of a versioned model.</p>
    #[serde(rename = "ModelPackageVersion")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_version: Option<i64>,
    #[serde(rename = "SourceAlgorithmSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_algorithm_specification: Option<SourceAlgorithmSpecification>,
    /// <p>A list of the tags associated with the model package. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS resources</a> in the <i>AWS General Reference Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    #[serde(rename = "ValidationSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub validation_specification: Option<ModelPackageValidationSpecification>,
}

/// <p>Describes the Docker container for the model package.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelPackageContainerDefinition {
    /// <p>The DNS host name for the Docker container.</p>
    #[serde(rename = "ContainerHostname")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_hostname: Option<String>,
    /// <p>The Amazon EC2 Container Registry (Amazon ECR) path where inference code is stored.</p> <p>If you are using your own custom algorithm instead of an algorithm provided by Amazon SageMaker, the inference code must meet Amazon SageMaker requirements. Amazon SageMaker supports both <code>registry/repository[:tag]</code> and <code>registry/repository[@digest]</code> image path formats. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms.html">Using Your Own Algorithms with Amazon SageMaker</a>.</p>
    #[serde(rename = "Image")]
    pub image: String,
    /// <p>An MD5 hash of the training algorithm that identifies the Docker image used for training.</p>
    #[serde(rename = "ImageDigest")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_digest: Option<String>,
    /// <p><p>The Amazon S3 path where the model artifacts, which result from model training, are stored. This path must point to a single <code>gzip</code> compressed tar archive (<code>.tar.gz</code> suffix).</p> <note> <p>The model artifacts must be in an S3 bucket that is in the same region as the model package.</p> </note></p>
    #[serde(rename = "ModelDataUrl")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_data_url: Option<String>,
    /// <p>The AWS Marketplace product ID of the model package.</p>
    #[serde(rename = "ProductId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub product_id: Option<String>,
}

/// <p>A group of versioned models in the model registry.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModelPackageGroup {
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>The time that the model group was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the model group.</p>
    #[serde(rename = "ModelPackageGroupArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_group_arn: Option<String>,
    /// <p>The description for the model group.</p>
    #[serde(rename = "ModelPackageGroupDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_group_description: Option<String>,
    /// <p>The name of the model group.</p>
    #[serde(rename = "ModelPackageGroupName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_group_name: Option<String>,
    /// <p><p>The status of the model group. This can be one of the following values.</p> <ul> <li> <p> <code>PENDING</code> - The model group is pending being created.</p> </li> <li> <p> <code>IN<em>PROGRESS</code> - The model group is in the process of being created.</p> </li> <li> <p> <code>COMPLETED</code> - The model group was successfully created.</p> </li> <li> <p> <code>FAILED</code> - The model group failed.</p> </li> <li> <p> <code>DELETING</code> - The model group is in the process of being deleted.</p> </li> <li> <p> <code>DELETE</em>FAILED</code> - SageMaker failed to delete the model group.</p> </li> </ul></p>
    #[serde(rename = "ModelPackageGroupStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_group_status: Option<String>,
    /// <p>A list of the tags associated with the model group. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS resources</a> in the <i>AWS General Reference Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

/// <p>Summary information about a model group.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModelPackageGroupSummary {
    /// <p>The time that the model group was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The Amazon Resource Name (ARN) of the model group.</p>
    #[serde(rename = "ModelPackageGroupArn")]
    pub model_package_group_arn: String,
    /// <p>A description of the model group.</p>
    #[serde(rename = "ModelPackageGroupDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_group_description: Option<String>,
    /// <p>The name of the model group.</p>
    #[serde(rename = "ModelPackageGroupName")]
    pub model_package_group_name: String,
    /// <p>The status of the model group.</p>
    #[serde(rename = "ModelPackageGroupStatus")]
    pub model_package_group_status: String,
}

/// <p>Specifies the validation and image scan statuses of the model package.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModelPackageStatusDetails {
    /// <p>The status of the scan of the Docker image container for the model package.</p>
    #[serde(rename = "ImageScanStatuses")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_scan_statuses: Option<Vec<ModelPackageStatusItem>>,
    /// <p>The validation status of the model package.</p>
    #[serde(rename = "ValidationStatuses")]
    pub validation_statuses: Vec<ModelPackageStatusItem>,
}

/// <p>Represents the overall status of a model package.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModelPackageStatusItem {
    /// <p>if the overall status is <code>Failed</code>, the reason for the failure.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The name of the model package for which the overall status is being reported.</p>
    #[serde(rename = "Name")]
    pub name: String,
    /// <p>The current status.</p>
    #[serde(rename = "Status")]
    pub status: String,
}

/// <p>Provides summary information about a model package.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModelPackageSummary {
    /// <p>A timestamp that shows when the model package was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p><p>The approval status of the model. This can be one of the following values.</p> <ul> <li> <p> <code>APPROVED</code> - The model is approved</p> </li> <li> <p> <code>REJECTED</code> - The model is rejected.</p> </li> <li> <p> <code>PENDING<em>MANUAL</em>APPROVAL</code> - The model is waiting for manual approval.</p> </li> </ul></p>
    #[serde(rename = "ModelApprovalStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_approval_status: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the model package.</p>
    #[serde(rename = "ModelPackageArn")]
    pub model_package_arn: String,
    /// <p>A brief description of the model package.</p>
    #[serde(rename = "ModelPackageDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_description: Option<String>,
    /// <p>If the model package is a versioned model, the model group that the versioned model belongs to.</p>
    #[serde(rename = "ModelPackageGroupName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_group_name: Option<String>,
    /// <p>The name of the model package.</p>
    #[serde(rename = "ModelPackageName")]
    pub model_package_name: String,
    /// <p>The overall status of the model package.</p>
    #[serde(rename = "ModelPackageStatus")]
    pub model_package_status: String,
    /// <p>If the model package is a versioned model, the version of the model.</p>
    #[serde(rename = "ModelPackageVersion")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_version: Option<i64>,
}

/// <p>Contains data, such as the inputs and targeted instance types that are used in the process of validating the model package.</p> <p>The data provided in the validation profile is made available to your buyers on AWS Marketplace.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelPackageValidationProfile {
    /// <p>The name of the profile for the model package.</p>
    #[serde(rename = "ProfileName")]
    pub profile_name: String,
    /// <p>The <code>TransformJobDefinition</code> object that describes the transform job used for the validation of the model package.</p>
    #[serde(rename = "TransformJobDefinition")]
    pub transform_job_definition: TransformJobDefinition,
}

/// <p>Specifies batch transform jobs that Amazon SageMaker runs to validate your model package.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelPackageValidationSpecification {
    /// <p>An array of <code>ModelPackageValidationProfile</code> objects, each of which specifies a batch transform job that Amazon SageMaker runs to validate your model package.</p>
    #[serde(rename = "ValidationProfiles")]
    pub validation_profiles: Vec<ModelPackageValidationProfile>,
    /// <p>The IAM roles to be used for the validation of the model package.</p>
    #[serde(rename = "ValidationRole")]
    pub validation_role: String,
}

/// <p>Model quality statistics and constraints.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelQuality {
    /// <p>Model quality constraints.</p>
    #[serde(rename = "Constraints")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub constraints: Option<MetricsSource>,
    /// <p>Model quality statistics.</p>
    #[serde(rename = "Statistics")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub statistics: Option<MetricsSource>,
}

/// <p>Container image configuration object for the monitoring job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelQualityAppSpecification {
    /// <p>An array of arguments for the container used to run the monitoring job.</p>
    #[serde(rename = "ContainerArguments")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_arguments: Option<Vec<String>>,
    /// <p>Specifies the entrypoint for a container that the monitoring job runs.</p>
    #[serde(rename = "ContainerEntrypoint")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_entrypoint: Option<Vec<String>>,
    /// <p>Sets the environment variables in the container that the monitoring job runs.</p>
    #[serde(rename = "Environment")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub environment: Option<::std::collections::HashMap<String, String>>,
    /// <p>The address of the container image that the monitoring job runs.</p>
    #[serde(rename = "ImageUri")]
    pub image_uri: String,
    /// <p>An Amazon S3 URI to a script that is called after analysis has been performed. Applicable only for the built-in (first party) containers.</p>
    #[serde(rename = "PostAnalyticsProcessorSourceUri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub post_analytics_processor_source_uri: Option<String>,
    /// <p>The machine learning problem type of the model that the monitoring job monitors.</p>
    #[serde(rename = "ProblemType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub problem_type: Option<String>,
    /// <p>An Amazon S3 URI to a script that is called per row prior to running analysis. It can base64 decode the payload and convert it into a flatted json so that the built-in container can use the converted data. Applicable only for the built-in (first party) containers.</p>
    #[serde(rename = "RecordPreprocessorSourceUri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub record_preprocessor_source_uri: Option<String>,
}

/// <p>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.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelQualityBaselineConfig {
    /// <p>The name of the job that performs baselining for the monitoring job.</p>
    #[serde(rename = "BaseliningJobName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub baselining_job_name: Option<String>,
    #[serde(rename = "ConstraintsResource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub constraints_resource: Option<MonitoringConstraintsResource>,
}

/// <p>The input for the model quality monitoring job. Currently endponts are supported for input for model quality monitoring jobs.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ModelQualityJobInput {
    #[serde(rename = "EndpointInput")]
    pub endpoint_input: EndpointInput,
    /// <p>The ground truth label provided for the model.</p>
    #[serde(rename = "GroundTruthS3Input")]
    pub ground_truth_s3_input: MonitoringGroundTruthS3Input,
}

/// <p>Metadata for Model steps.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModelStepMetadata {
    /// <p>The Amazon Resource Name (ARN) of the created model.</p>
    #[serde(rename = "Arn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub arn: Option<String>,
}

/// <p>Provides summary information about a model.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModelSummary {
    /// <p>A timestamp that indicates when the model was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The Amazon Resource Name (ARN) of the model.</p>
    #[serde(rename = "ModelArn")]
    pub model_arn: String,
    /// <p>The name of the model that you want a summary for.</p>
    #[serde(rename = "ModelName")]
    pub model_name: String,
}

/// <p>Container image configuration object for the monitoring job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MonitoringAppSpecification {
    /// <p>An array of arguments for the container used to run the monitoring job.</p>
    #[serde(rename = "ContainerArguments")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_arguments: Option<Vec<String>>,
    /// <p>Specifies the entrypoint for a container used to run the monitoring job.</p>
    #[serde(rename = "ContainerEntrypoint")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_entrypoint: Option<Vec<String>>,
    /// <p>The container image to be run by the monitoring job.</p>
    #[serde(rename = "ImageUri")]
    pub image_uri: String,
    /// <p>An Amazon S3 URI to a script that is called after analysis has been performed. Applicable only for the built-in (first party) containers.</p>
    #[serde(rename = "PostAnalyticsProcessorSourceUri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub post_analytics_processor_source_uri: Option<String>,
    /// <p>An Amazon S3 URI to a script that is called per row prior to running analysis. It can base64 decode the payload and convert it into a flatted json so that the built-in container can use the converted data. Applicable only for the built-in (first party) containers.</p>
    #[serde(rename = "RecordPreprocessorSourceUri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub record_preprocessor_source_uri: Option<String>,
}

/// <p>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.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MonitoringBaselineConfig {
    /// <p>The name of the job that performs baselining for the monitoring job.</p>
    #[serde(rename = "BaseliningJobName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub baselining_job_name: Option<String>,
    /// <p>The baseline constraint file in Amazon S3 that the current monitoring job should validated against.</p>
    #[serde(rename = "ConstraintsResource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub constraints_resource: Option<MonitoringConstraintsResource>,
    /// <p>The baseline statistics file in Amazon S3 that the current monitoring job should be validated against.</p>
    #[serde(rename = "StatisticsResource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub statistics_resource: Option<MonitoringStatisticsResource>,
}

/// <p>Configuration for the cluster used to run model monitoring jobs.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MonitoringClusterConfig {
    /// <p>The number of ML compute instances to use in the model monitoring job. For distributed processing jobs, specify a value greater than 1. The default value is 1.</p>
    #[serde(rename = "InstanceCount")]
    pub instance_count: i64,
    /// <p>The ML compute instance type for the processing job.</p>
    #[serde(rename = "InstanceType")]
    pub instance_type: String,
    /// <p>The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt data on the storage volume attached to the ML compute instance(s) that run the model monitoring job.</p>
    #[serde(rename = "VolumeKmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume_kms_key_id: Option<String>,
    /// <p>The size of the ML storage volume, in gigabytes, that you want to provision. You must specify sufficient ML storage for your scenario.</p>
    #[serde(rename = "VolumeSizeInGB")]
    pub volume_size_in_gb: i64,
}

/// <p>The constraints resource for a monitoring job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MonitoringConstraintsResource {
    /// <p>The Amazon S3 URI for the constraints resource.</p>
    #[serde(rename = "S3Uri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_uri: Option<String>,
}

/// <p>Summary of information about the last monitoring job to run.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MonitoringExecutionSummary {
    /// <p>The time at which the monitoring job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The name of the endpoint used to run the monitoring job.</p>
    #[serde(rename = "EndpointName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endpoint_name: Option<String>,
    /// <p>Contains the reason a monitoring job failed, if it failed.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>A timestamp that indicates the last time the monitoring job was modified.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
    /// <p>The status of the monitoring job.</p>
    #[serde(rename = "MonitoringExecutionStatus")]
    pub monitoring_execution_status: String,
    /// <p>The name of the monitoring job.</p>
    #[serde(rename = "MonitoringJobDefinitionName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_job_definition_name: Option<String>,
    /// <p>The name of the monitoring schedule.</p>
    #[serde(rename = "MonitoringScheduleName")]
    pub monitoring_schedule_name: String,
    /// <p>The type of the monitoring job.</p>
    #[serde(rename = "MonitoringType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_type: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the monitoring job.</p>
    #[serde(rename = "ProcessingJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_job_arn: Option<String>,
    /// <p>The time the monitoring job was scheduled.</p>
    #[serde(rename = "ScheduledTime")]
    pub scheduled_time: f64,
}

/// <p>The ground truth labels for the dataset used for the monitoring job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MonitoringGroundTruthS3Input {
    /// <p>The address of the Amazon S3 location of the ground truth labels.</p>
    #[serde(rename = "S3Uri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_uri: Option<String>,
}

/// <p>The inputs for a monitoring job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MonitoringInput {
    /// <p>The endpoint for a monitoring job.</p>
    #[serde(rename = "EndpointInput")]
    pub endpoint_input: EndpointInput,
}

/// <p>Defines the monitoring job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MonitoringJobDefinition {
    /// <p>Baseline configuration used to validate that the data conforms to the specified constraints and statistics</p>
    #[serde(rename = "BaselineConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub baseline_config: Option<MonitoringBaselineConfig>,
    /// <p>Sets the environment variables in the Docker container.</p>
    #[serde(rename = "Environment")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub environment: Option<::std::collections::HashMap<String, String>>,
    /// <p>Configures the monitoring job to run a specified Docker container image.</p>
    #[serde(rename = "MonitoringAppSpecification")]
    pub monitoring_app_specification: MonitoringAppSpecification,
    /// <p>The array of inputs for the monitoring job. Currently we support monitoring an Amazon SageMaker Endpoint.</p>
    #[serde(rename = "MonitoringInputs")]
    pub monitoring_inputs: Vec<MonitoringInput>,
    /// <p>The array of outputs from the monitoring job to be uploaded to Amazon Simple Storage Service (Amazon S3).</p>
    #[serde(rename = "MonitoringOutputConfig")]
    pub monitoring_output_config: MonitoringOutputConfig,
    /// <p>Identifies the resources, ML compute instances, and ML storage volumes to deploy for a monitoring job. In distributed processing, you specify more than one instance.</p>
    #[serde(rename = "MonitoringResources")]
    pub monitoring_resources: MonitoringResources,
    /// <p>Specifies networking options for an monitoring job.</p>
    #[serde(rename = "NetworkConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub network_config: Option<NetworkConfig>,
    /// <p>The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume to perform tasks on your behalf.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    /// <p>Specifies a time limit for how long the monitoring job is allowed to run.</p>
    #[serde(rename = "StoppingCondition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopping_condition: Option<MonitoringStoppingCondition>,
}

/// <p>Summary information about a monitoring job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MonitoringJobDefinitionSummary {
    /// <p>The time that the monitoring job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The name of the endpoint that the job monitors.</p>
    #[serde(rename = "EndpointName")]
    pub endpoint_name: String,
    /// <p>The Amazon Resource Name (ARN) of the monitoring job.</p>
    #[serde(rename = "MonitoringJobDefinitionArn")]
    pub monitoring_job_definition_arn: String,
    /// <p>The name of the monitoring job.</p>
    #[serde(rename = "MonitoringJobDefinitionName")]
    pub monitoring_job_definition_name: String,
}

/// <p>The networking configuration for the monitoring job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MonitoringNetworkConfig {
    /// <p>Whether to encrypt all communications between the instances used for the monitoring jobs. Choose <code>True</code> to encrypt communications. Encryption provides greater security for distributed jobs, but the processing might take longer.</p>
    #[serde(rename = "EnableInterContainerTrafficEncryption")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_inter_container_traffic_encryption: Option<bool>,
    /// <p>Whether to allow inbound and outbound network calls to and from the containers used for the monitoring job.</p>
    #[serde(rename = "EnableNetworkIsolation")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_network_isolation: Option<bool>,
    #[serde(rename = "VpcConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpc_config: Option<VpcConfig>,
}

/// <p>The output object for a monitoring job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MonitoringOutput {
    /// <p>The Amazon S3 storage location where the results of a monitoring job are saved.</p>
    #[serde(rename = "S3Output")]
    pub s3_output: MonitoringS3Output,
}

/// <p>The output configuration for monitoring jobs.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MonitoringOutputConfig {
    /// <p>The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt the model artifacts at rest using Amazon S3 server-side encryption.</p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>Monitoring outputs for monitoring jobs. This is where the output of the periodic monitoring jobs is uploaded.</p>
    #[serde(rename = "MonitoringOutputs")]
    pub monitoring_outputs: Vec<MonitoringOutput>,
}

/// <p>Identifies the resources to deploy for a monitoring job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MonitoringResources {
    /// <p>The configuration for the cluster resources used to run the processing job.</p>
    #[serde(rename = "ClusterConfig")]
    pub cluster_config: MonitoringClusterConfig,
}

/// <p>Information about where and how you want to store the results of a monitoring job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MonitoringS3Output {
    /// <p>The local path to the Amazon S3 storage location where Amazon SageMaker saves the results of a monitoring job. LocalPath is an absolute path for the output data.</p>
    #[serde(rename = "LocalPath")]
    pub local_path: String,
    /// <p>Whether to upload the results of the monitoring job continuously or after the job completes.</p>
    #[serde(rename = "S3UploadMode")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_upload_mode: Option<String>,
    /// <p>A URI that identifies the Amazon S3 storage location where Amazon SageMaker saves the results of a monitoring job.</p>
    #[serde(rename = "S3Uri")]
    pub s3_uri: String,
}

/// <p>A schedule for a model monitoring job. For information about model monitor, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor.html">Amazon SageMaker Model Monitor</a>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MonitoringSchedule {
    /// <p>The time that the monitoring schedule was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The endpoint that hosts the model being monitored.</p>
    #[serde(rename = "EndpointName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endpoint_name: Option<String>,
    /// <p>If the monitoring schedule failed, the reason it failed.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The last time the monitoring schedule was changed.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    #[serde(rename = "LastMonitoringExecutionSummary")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_monitoring_execution_summary: Option<MonitoringExecutionSummary>,
    /// <p>The Amazon Resource Name (ARN) of the monitoring schedule.</p>
    #[serde(rename = "MonitoringScheduleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_schedule_arn: Option<String>,
    #[serde(rename = "MonitoringScheduleConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_schedule_config: Option<MonitoringScheduleConfig>,
    /// <p>The name of the monitoring schedule.</p>
    #[serde(rename = "MonitoringScheduleName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_schedule_name: Option<String>,
    /// <p><p>The status of the monitoring schedule. This can be one of the following values.</p> <ul> <li> <p> <code>PENDING</code> - The schedule is pending being created.</p> </li> <li> <p> <code>FAILED</code> - The schedule failed.</p> </li> <li> <p> <code>SCHEDULED</code> - The schedule was successfully created.</p> </li> <li> <p> <code>STOPPED</code> - The schedule was stopped.</p> </li> </ul></p>
    #[serde(rename = "MonitoringScheduleStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_schedule_status: Option<String>,
    /// <p>The type of the monitoring job definition to schedule.</p>
    #[serde(rename = "MonitoringType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_type: Option<String>,
    /// <p>A list of the tags associated with the monitoring schedlue. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS resources</a> in the <i>AWS General Reference Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

/// <p>Configures the monitoring schedule and defines the monitoring job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MonitoringScheduleConfig {
    /// <p>Defines the monitoring job.</p>
    #[serde(rename = "MonitoringJobDefinition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_job_definition: Option<MonitoringJobDefinition>,
    /// <p>The name of the monitoring job definition to schedule.</p>
    #[serde(rename = "MonitoringJobDefinitionName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_job_definition_name: Option<String>,
    /// <p>The type of the monitoring job definition to schedule.</p>
    #[serde(rename = "MonitoringType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_type: Option<String>,
    /// <p>Configures the monitoring schedule.</p>
    #[serde(rename = "ScheduleConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub schedule_config: Option<ScheduleConfig>,
}

/// <p>Summarizes the monitoring schedule.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MonitoringScheduleSummary {
    /// <p>The creation time of the monitoring schedule.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The name of the endpoint using the monitoring schedule.</p>
    #[serde(rename = "EndpointName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endpoint_name: Option<String>,
    /// <p>The last time the monitoring schedule was modified.</p>
    #[serde(rename = "LastModifiedTime")]
    pub last_modified_time: f64,
    /// <p>The name of the monitoring job definition that the schedule is for.</p>
    #[serde(rename = "MonitoringJobDefinitionName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_job_definition_name: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the monitoring schedule.</p>
    #[serde(rename = "MonitoringScheduleArn")]
    pub monitoring_schedule_arn: String,
    /// <p>The name of the monitoring schedule.</p>
    #[serde(rename = "MonitoringScheduleName")]
    pub monitoring_schedule_name: String,
    /// <p>The status of the monitoring schedule.</p>
    #[serde(rename = "MonitoringScheduleStatus")]
    pub monitoring_schedule_status: String,
    /// <p>The type of the monitoring job definition that the schedule is for.</p>
    #[serde(rename = "MonitoringType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_type: Option<String>,
}

/// <p>The statistics resource for a monitoring job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MonitoringStatisticsResource {
    /// <p>The Amazon S3 URI for the statistics resource.</p>
    #[serde(rename = "S3Uri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_uri: Option<String>,
}

/// <p>A time limit for how long the monitoring job is allowed to run before stopping.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MonitoringStoppingCondition {
    /// <p>The maximum runtime allowed in seconds.</p>
    #[serde(rename = "MaxRuntimeInSeconds")]
    pub max_runtime_in_seconds: i64,
}

/// <p><p>A list of nested <a>Filter</a> objects. A resource must satisfy the conditions of all filters to be included in the results returned from the <a>Search</a> API.</p> <p>For example, to filter on a training job&#39;s <code>InputDataConfig</code> property with a specific channel name and <code>S3Uri</code> prefix, define the following filters:</p> <ul> <li> <p> <code>&#39;{Name:&quot;InputDataConfig.ChannelName&quot;, &quot;Operator&quot;:&quot;Equals&quot;, &quot;Value&quot;:&quot;train&quot;}&#39;,</code> </p> </li> <li> <p> <code>&#39;{Name:&quot;InputDataConfig.DataSource.S3DataSource.S3Uri&quot;, &quot;Operator&quot;:&quot;Contains&quot;, &quot;Value&quot;:&quot;mybucket/catdata&quot;}&#39;</code> </p> </li> </ul></p>
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct NestedFilters {
    /// <p>A list of filters. Each filter acts on a property. Filters must contain at least one <code>Filters</code> value. For example, a <code>NestedFilters</code> call might include a filter on the <code>PropertyName</code> parameter of the <code>InputDataConfig</code> property: <code>InputDataConfig.DataSource.S3DataSource.S3Uri</code>.</p>
    #[serde(rename = "Filters")]
    pub filters: Vec<Filter>,
    /// <p>The name of the property to use in the nested filters. The value must match a listed property name, such as <code>InputDataConfig</code>.</p>
    #[serde(rename = "NestedPropertyName")]
    pub nested_property_name: String,
}

/// <p>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.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct NetworkConfig {
    /// <p>Whether to encrypt all communications between distributed processing jobs. Choose <code>True</code> to encrypt communications. Encryption provides greater security for distributed processing jobs, but the processing might take longer.</p>
    #[serde(rename = "EnableInterContainerTrafficEncryption")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_inter_container_traffic_encryption: Option<bool>,
    /// <p>Whether to allow inbound and outbound network calls to and from the containers used for the processing job.</p>
    #[serde(rename = "EnableNetworkIsolation")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_network_isolation: Option<bool>,
    #[serde(rename = "VpcConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpc_config: Option<VpcConfig>,
}

/// <p>Provides a summary of a notebook instance lifecycle configuration.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NotebookInstanceLifecycleConfigSummary {
    /// <p>A timestamp that tells when the lifecycle configuration was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>A timestamp that tells when the lifecycle configuration was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the lifecycle configuration.</p>
    #[serde(rename = "NotebookInstanceLifecycleConfigArn")]
    pub notebook_instance_lifecycle_config_arn: String,
    /// <p>The name of the lifecycle configuration.</p>
    #[serde(rename = "NotebookInstanceLifecycleConfigName")]
    pub notebook_instance_lifecycle_config_name: String,
}

/// <p>Contains the notebook instance lifecycle configuration script.</p> <p>Each lifecycle configuration script has a limit of 16384 characters.</p> <p>The value of the <code>$PATH</code> environment variable that is available to both scripts is <code>/sbin:bin:/usr/sbin:/usr/bin</code>.</p> <p>View CloudWatch Logs for notebook instance lifecycle configurations in log group <code>/aws/sagemaker/NotebookInstances</code> in log stream <code>[notebook-instance-name]/[LifecycleConfigHook]</code>.</p> <p>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.</p> <p>For information about notebook instance lifestyle configurations, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/notebook-lifecycle-config.html">Step 2.1: (Optional) Customize a Notebook Instance</a>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct NotebookInstanceLifecycleHook {
    /// <p>A base64-encoded string that contains a shell script for a notebook instance lifecycle configuration.</p>
    #[serde(rename = "Content")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
}

/// <p>Provides summary information for an Amazon SageMaker notebook instance.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NotebookInstanceSummary {
    /// <p>An array of up to three Git repositories associated with the notebook instance. These can be either the names of Git repositories stored as resources in your account, or the URL of Git repositories in <a href="https://docs.aws.amazon.com/codecommit/latest/userguide/welcome.html">AWS CodeCommit</a> or in any other Git repository. These repositories are cloned at the same level as the default repository of your notebook instance. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/nbi-git-repo.html">Associating Git Repositories with Amazon SageMaker Notebook Instances</a>.</p>
    #[serde(rename = "AdditionalCodeRepositories")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub additional_code_repositories: Option<Vec<String>>,
    /// <p>A timestamp that shows when the notebook instance was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The Git repository associated with the notebook instance as its default code repository. This can be either the name of a Git repository stored as a resource in your account, or the URL of a Git repository in <a href="https://docs.aws.amazon.com/codecommit/latest/userguide/welcome.html">AWS CodeCommit</a> or in any other Git repository. When you open a notebook instance, it opens in the directory that contains this repository. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/nbi-git-repo.html">Associating Git Repositories with Amazon SageMaker Notebook Instances</a>.</p>
    #[serde(rename = "DefaultCodeRepository")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_code_repository: Option<String>,
    /// <p>The type of ML compute instance that the notebook instance is running on.</p>
    #[serde(rename = "InstanceType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub instance_type: Option<String>,
    /// <p>A timestamp that shows when the notebook instance was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the notebook instance.</p>
    #[serde(rename = "NotebookInstanceArn")]
    pub notebook_instance_arn: String,
    /// <p>The name of a notebook instance lifecycle configuration associated with this notebook instance.</p> <p>For information about notebook instance lifestyle configurations, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/notebook-lifecycle-config.html">Step 2.1: (Optional) Customize a Notebook Instance</a>.</p>
    #[serde(rename = "NotebookInstanceLifecycleConfigName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_instance_lifecycle_config_name: Option<String>,
    /// <p>The name of the notebook instance that you want a summary for.</p>
    #[serde(rename = "NotebookInstanceName")]
    pub notebook_instance_name: String,
    /// <p>The status of the notebook instance.</p>
    #[serde(rename = "NotebookInstanceStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_instance_status: Option<String>,
    /// <p>The URL that you use to connect to the Jupyter instance running in your notebook instance. </p>
    #[serde(rename = "Url")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

/// <p>Configures SNS notifications of available or expiring work items for work teams.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct NotificationConfiguration {
    /// <p>The ARN for the SNS topic to which notifications should be published.</p>
    #[serde(rename = "NotificationTopicArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notification_topic_arn: Option<String>,
}

/// <p>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.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ObjectiveStatusCounters {
    /// <p>The number of training jobs whose final objective metric was not evaluated and used in the hyperparameter tuning process. This typically occurs when the training job failed or did not emit an objective metric.</p>
    #[serde(rename = "Failed")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failed: Option<i64>,
    /// <p>The number of training jobs that are in progress and pending evaluation of their final objective metric.</p>
    #[serde(rename = "Pending")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pending: Option<i64>,
    /// <p>The number of training jobs whose final objective metric was evaluated by the hyperparameter tuning job and used in the hyperparameter tuning process.</p>
    #[serde(rename = "Succeeded")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub succeeded: Option<i64>,
}

/// <p>The configuration of an <code>OfflineStore</code>.</p> <p>Provide an <code>OfflineStoreConfig</code> in a request to <code>CreateFeatureGroup</code> to create an <code>OfflineStore</code>.</p> <p>To encrypt an <code>OfflineStore</code> using at rest data encryption, specify AWS Key Management Service (KMS) key ID, or <code>KMSKeyId</code>, in <code>S3StorageConfig</code>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OfflineStoreConfig {
    /// <p>The meta data of the Glue table that is autogenerated when an <code>OfflineStore</code> is created. </p>
    #[serde(rename = "DataCatalogConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data_catalog_config: Option<DataCatalogConfig>,
    /// <p>Set to <code>True</code> to disable the automatic creation of an AWS Glue table when configuring an <code>OfflineStore</code>.</p>
    #[serde(rename = "DisableGlueTableCreation")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disable_glue_table_creation: Option<bool>,
    /// <p>The Amazon Simple Storage (Amazon S3) location of <code>OfflineStore</code>.</p>
    #[serde(rename = "S3StorageConfig")]
    pub s3_storage_config: S3StorageConfig,
}

/// <p>The status of <code>OfflineStore</code>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OfflineStoreStatus {
    /// <p>The justification for why the OfflineStoreStatus is Blocked (if applicable).</p>
    #[serde(rename = "BlockedReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub blocked_reason: Option<String>,
    /// <p>An <code>OfflineStore</code> status.</p>
    #[serde(rename = "Status")]
    pub status: String,
}

/// <p>Use this parameter to configure your OIDC Identity Provider (IdP).</p>
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OidcConfig {
    /// <p>The OIDC IdP authorization endpoint used to configure your private workforce.</p>
    #[serde(rename = "AuthorizationEndpoint")]
    pub authorization_endpoint: String,
    /// <p>The OIDC IdP client ID used to configure your private workforce.</p>
    #[serde(rename = "ClientId")]
    pub client_id: String,
    /// <p>The OIDC IdP client secret used to configure your private workforce.</p>
    #[serde(rename = "ClientSecret")]
    pub client_secret: String,
    /// <p>The OIDC IdP issuer used to configure your private workforce.</p>
    #[serde(rename = "Issuer")]
    pub issuer: String,
    /// <p>The OIDC IdP JSON Web Key Set (Jwks) URI used to configure your private workforce.</p>
    #[serde(rename = "JwksUri")]
    pub jwks_uri: String,
    /// <p>The OIDC IdP logout endpoint used to configure your private workforce.</p>
    #[serde(rename = "LogoutEndpoint")]
    pub logout_endpoint: String,
    /// <p>The OIDC IdP token endpoint used to configure your private workforce.</p>
    #[serde(rename = "TokenEndpoint")]
    pub token_endpoint: String,
    /// <p>The OIDC IdP user information endpoint used to configure your private workforce.</p>
    #[serde(rename = "UserInfoEndpoint")]
    pub user_info_endpoint: String,
}

/// <p>Your OIDC IdP workforce configuration.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OidcConfigForResponse {
    /// <p>The OIDC IdP authorization endpoint used to configure your private workforce.</p>
    #[serde(rename = "AuthorizationEndpoint")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub authorization_endpoint: Option<String>,
    /// <p>The OIDC IdP client ID used to configure your private workforce.</p>
    #[serde(rename = "ClientId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client_id: Option<String>,
    /// <p>The OIDC IdP issuer used to configure your private workforce.</p>
    #[serde(rename = "Issuer")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub issuer: Option<String>,
    /// <p>The OIDC IdP JSON Web Key Set (Jwks) URI used to configure your private workforce.</p>
    #[serde(rename = "JwksUri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jwks_uri: Option<String>,
    /// <p>The OIDC IdP logout endpoint used to configure your private workforce.</p>
    #[serde(rename = "LogoutEndpoint")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub logout_endpoint: Option<String>,
    /// <p>The OIDC IdP token endpoint used to configure your private workforce.</p>
    #[serde(rename = "TokenEndpoint")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub token_endpoint: Option<String>,
    /// <p>The OIDC IdP user information endpoint used to configure your private workforce.</p>
    #[serde(rename = "UserInfoEndpoint")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_info_endpoint: Option<String>,
}

/// <p>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 <code>Groups</code>, 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.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OidcMemberDefinition {
    /// <p>A list of comma seperated strings that identifies user groups in your OIDC IdP. Each user group is made up of a group of private workers.</p>
    #[serde(rename = "Groups")]
    pub groups: Vec<String>,
}

/// <p>Use this to specify the AWS Key Management Service (KMS) Key ID, or <code>KMSKeyId</code>, for at rest data encryption. You can turn <code>OnlineStore</code> on or off by specifying the <code>EnableOnlineStore</code> flag at General Assembly; the default value is <code>False</code>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OnlineStoreConfig {
    /// <p>Turn <code>OnlineStore</code> off by specifying <code>False</code> for the <code>EnableOnlineStore</code> flag. Turn <code>OnlineStore</code> on by specifying <code>True</code> for the <code>EnableOnlineStore</code> flag. </p> <p>The default value is <code>False</code>.</p>
    #[serde(rename = "EnableOnlineStore")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_online_store: Option<bool>,
    /// <p>Use to specify KMS Key ID (<code>KMSKeyId</code>) for at-rest encryption of your <code>OnlineStore</code>.</p>
    #[serde(rename = "SecurityConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub security_config: Option<OnlineStoreSecurityConfig>,
}

/// <p>The security configuration for <code>OnlineStore</code>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OnlineStoreSecurityConfig {
    /// <p><p>The ID of the AWS Key Management Service (AWS KMS) key that SageMaker Feature Store uses to encrypt the Amazon S3 objects at rest using Amazon S3 server-side encryption.</p> <p>The caller (either IAM user or IAM role) of <code>CreateFeatureGroup</code> must have below permissions to the <code>OnlineStore</code> <code>KmsKeyId</code>:</p> <ul> <li> <p> <code>&quot;kms:Encrypt&quot;</code> </p> </li> <li> <p> <code>&quot;kms:Decrypt&quot;</code> </p> </li> <li> <p> <code>&quot;kms:DescribeKey&quot;</code> </p> </li> <li> <p> <code>&quot;kms:CreateGrant&quot;</code> </p> </li> <li> <p> <code>&quot;kms:RetireGrant&quot;</code> </p> </li> <li> <p> <code>&quot;kms:ReEncryptFrom&quot;</code> </p> </li> <li> <p> <code>&quot;kms:ReEncryptTo&quot;</code> </p> </li> <li> <p> <code>&quot;kms:GenerateDataKey&quot;</code> </p> </li> <li> <p> <code>&quot;kms:ListAliases&quot;</code> </p> </li> <li> <p> <code>&quot;kms:ListGrants&quot;</code> </p> </li> <li> <p> <code>&quot;kms:RevokeGrant&quot;</code> </p> </li> </ul> <p>The caller (either IAM user or IAM role) to all DataPlane operations (<code>PutRecord</code>, <code>GetRecord</code>, <code>DeleteRecord</code>) must have the following permissions to the <code>KmsKeyId</code>:</p> <ul> <li> <p> <code>&quot;kms:Decrypt&quot;</code> </p> </li> </ul></p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
}

/// <p>Contains information about the output location for the compiled model and the target device that the model runs on. <code>TargetDevice</code> and <code>TargetPlatform</code> are 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 the <code>TargetDevice</code> list, use <code>TargetPlatform</code> to describe the platform of your edge device and <code>CompilerOptions</code> if there are specific settings that are required or recommended to use for particular TargetPlatform.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OutputConfig {
    /// <p><p>Specifies additional parameters for compiler options in JSON format. The compiler options are <code>TargetPlatform</code> specific. It is required for NVIDIA accelerators and highly recommended for CPU compilations. For any other cases, it is optional to specify <code>CompilerOptions.</code> </p> <ul> <li> <p> <code>CPU</code>: Compilation for CPU supports the following compiler options.</p> <ul> <li> <p> <code>mcpu</code>: CPU micro-architecture. For example, <code>{&#39;mcpu&#39;: &#39;skylake-avx512&#39;}</code> </p> </li> <li> <p> <code>mattr</code>: CPU flags. For example, <code>{&#39;mattr&#39;: [&#39;+neon&#39;, &#39;+vfpv4&#39;]}</code> </p> </li> </ul> </li> <li> <p> <code>ARM</code>: Details of ARM CPU compilations.</p> <ul> <li> <p> <code>NEON</code>: NEON is an implementation of the Advanced SIMD extension used in ARMv7 processors.</p> <p>For example, add <code>{&#39;mattr&#39;: [&#39;+neon&#39;]}</code> to the compiler options if compiling for ARM 32-bit platform with the NEON support.</p> </li> </ul> </li> <li> <p> <code>NVIDIA</code>: Compilation for NVIDIA GPU supports the following compiler options.</p> <ul> <li> <p> <code>gpu<em>code</code>: Specifies the targeted architecture.</p> </li> <li> <p> <code>trt-ver</code>: Specifies the TensorRT versions in x.y.z. format.</p> </li> <li> <p> <code>cuda-ver</code>: Specifies the CUDA version in x.y format.</p> </li> </ul> <p>For example, <code>{&#39;gpu-code&#39;: &#39;sm</em>72&#39;, &#39;trt-ver&#39;: &#39;6.0.1&#39;, &#39;cuda-ver&#39;: &#39;10.1&#39;}</code> </p> </li> <li> <p> <code>ANDROID</code>: Compilation for the Android OS supports the following compiler options:</p> <ul> <li> <p> <code>ANDROID<em>PLATFORM</code>: Specifies the Android API levels. Available levels range from 21 to 29. For example, <code>{&#39;ANDROID</em>PLATFORM&#39;: 28}</code>.</p> </li> <li> <p> <code>mattr</code>: Add <code>{&#39;mattr&#39;: [&#39;+neon&#39;]}</code> to compiler options if compiling for ARM 32-bit platform with NEON support.</p> </li> </ul> </li> <li> <p> <code>INFERENTIA</code>: Compilation for target ml<em>inf1 uses compiler options passed in as a JSON string. For example, <code>&quot;CompilerOptions&quot;: &quot;&quot;--verbose 1 --num-neuroncores 2 -O2&quot;&quot;</code>. </p> <p>For information about supported compiler options, see <a href="https://github.com/aws/aws-neuron-sdk/blob/master/docs/neuron-cc/command-line-reference.md"> Neuron Compiler CLI</a>. </p> </li> <li> <p> <code>CoreML</code>: Compilation for the CoreML <a>OutputConfig$TargetDevice</a> supports the following compiler options:</p> <ul> <li> <p> <code>class</em>labels</code>: Specifies the classification labels file name inside input tar.gz file. For example, <code>{&quot;class<em>labels&quot;: &quot;imagenet</em>labels_1000.txt&quot;}</code>. Labels inside the txt file should be separated by newlines.</p> </li> </ul> </li> </ul></p>
    #[serde(rename = "CompilerOptions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub compiler_options: Option<String>,
    /// <p><p>The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt data on the storage volume after compilation job. If you don&#39;t provide a KMS key ID, Amazon SageMaker uses the default KMS key for Amazon S3 for your role&#39;s account</p> <p>The KmsKeyId can be any of the following formats: </p> <ul> <li> <p>Key ID: <code>1234abcd-12ab-34cd-56ef-1234567890ab</code> </p> </li> <li> <p>Key ARN: <code>arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab</code> </p> </li> <li> <p>Alias name: <code>alias/ExampleAlias</code> </p> </li> <li> <p>Alias name ARN: <code>arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias</code> </p> </li> </ul></p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>Identifies the S3 bucket where you want Amazon SageMaker to store the model artifacts. For example, <code>s3://bucket-name/key-name-prefix</code>.</p>
    #[serde(rename = "S3OutputLocation")]
    pub s3_output_location: String,
    /// <p>Identifies the target device or the machine learning instance that you want to run your model on after the compilation has completed. Alternatively, you can specify OS, architecture, and accelerator using <a>TargetPlatform</a> fields. It can be used instead of <code>TargetPlatform</code>.</p>
    #[serde(rename = "TargetDevice")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub target_device: Option<String>,
    /// <p><p>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 <code>TargetDevice</code>.</p> <p>The following examples show how to configure the <code>TargetPlatform</code> and <code>CompilerOptions</code> JSON strings for popular target platforms: </p> <ul> <li> <p>Raspberry Pi 3 Model B+</p> <p> <code>&quot;TargetPlatform&quot;: {&quot;Os&quot;: &quot;LINUX&quot;, &quot;Arch&quot;: &quot;ARM<em>EABIHF&quot;},</code> </p> <p> <code> &quot;CompilerOptions&quot;: {&#39;mattr&#39;: [&#39;+neon&#39;]}</code> </p> </li> <li> <p>Jetson TX2</p> <p> <code>&quot;TargetPlatform&quot;: {&quot;Os&quot;: &quot;LINUX&quot;, &quot;Arch&quot;: &quot;ARM64&quot;, &quot;Accelerator&quot;: &quot;NVIDIA&quot;},</code> </p> <p> <code> &quot;CompilerOptions&quot;: {&#39;gpu-code&#39;: &#39;sm</em>62&#39;, &#39;trt-ver&#39;: &#39;6.0.1&#39;, &#39;cuda-ver&#39;: &#39;10.0&#39;}</code> </p> </li> <li> <p>EC2 m5.2xlarge instance OS</p> <p> <code>&quot;TargetPlatform&quot;: {&quot;Os&quot;: &quot;LINUX&quot;, &quot;Arch&quot;: &quot;X86<em>64&quot;, &quot;Accelerator&quot;: &quot;NVIDIA&quot;},</code> </p> <p> <code> &quot;CompilerOptions&quot;: {&#39;mcpu&#39;: &#39;skylake-avx512&#39;}</code> </p> </li> <li> <p>RK3399</p> <p> <code>&quot;TargetPlatform&quot;: {&quot;Os&quot;: &quot;LINUX&quot;, &quot;Arch&quot;: &quot;ARM64&quot;, &quot;Accelerator&quot;: &quot;MALI&quot;}</code> </p> </li> <li> <p>ARMv7 phone (CPU)</p> <p> <code>&quot;TargetPlatform&quot;: {&quot;Os&quot;: &quot;ANDROID&quot;, &quot;Arch&quot;: &quot;ARM</em>EABI&quot;},</code> </p> <p> <code> &quot;CompilerOptions&quot;: {&#39;ANDROID<em>PLATFORM&#39;: 25, &#39;mattr&#39;: [&#39;+neon&#39;]}</code> </p> </li> <li> <p>ARMv8 phone (CPU)</p> <p> <code>&quot;TargetPlatform&quot;: {&quot;Os&quot;: &quot;ANDROID&quot;, &quot;Arch&quot;: &quot;ARM64&quot;},</code> </p> <p> <code> &quot;CompilerOptions&quot;: {&#39;ANDROID</em>PLATFORM&#39;: 29}</code> </p> </li> </ul></p>
    #[serde(rename = "TargetPlatform")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub target_platform: Option<TargetPlatform>,
}

/// <p>Provides information about how to store model training results (model artifacts).</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OutputDataConfig {
    /// <p>The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt the model artifacts at rest using Amazon S3 server-side encryption. The <code>KmsKeyId</code> can be any of the following formats: </p> <ul> <li> <p>// KMS Key ID</p> <p> <code>"1234abcd-12ab-34cd-56ef-1234567890ab"</code> </p> </li> <li> <p>// Amazon Resource Name (ARN) of a KMS Key</p> <p> <code>"arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"</code> </p> </li> <li> <p>// KMS Key Alias</p> <p> <code>"alias/ExampleAlias"</code> </p> </li> <li> <p>// Amazon Resource Name (ARN) of a KMS Key Alias</p> <p> <code>"arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias"</code> </p> </li> </ul> <p>If you use a KMS key ID or an alias of your master key, the Amazon SageMaker execution role must include permissions to call <code>kms:Encrypt</code>. If you don't provide a KMS key ID, Amazon SageMaker uses the default KMS key for Amazon S3 for your role's account. Amazon SageMaker uses server-side encryption with KMS-managed keys for <code>OutputDataConfig</code>. If you use a bucket policy with an <code>s3:PutObject</code> permission that only allows objects with server-side encryption, set the condition key of <code>s3:x-amz-server-side-encryption</code> to <code>"aws:kms"</code>. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html">KMS-Managed Encryption Keys</a> in the <i>Amazon Simple Storage Service Developer Guide.</i> </p> <p>The KMS key policy must grant permission to the IAM role that you specify in your <code>CreateTrainingJob</code>, <code>CreateTransformJob</code>, or <code>CreateHyperParameterTuningJob</code> requests. For more information, see <a href="http://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html">Using Key Policies in AWS KMS</a> in the <i>AWS Key Management Service Developer Guide</i>.</p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>Identifies the S3 path where you want Amazon SageMaker to store the model artifacts. For example, <code>s3://bucket-name/key-name-prefix</code>. </p>
    #[serde(rename = "S3OutputPath")]
    pub s3_output_path: String,
}

/// <p>Assigns a value to a named Pipeline parameter.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Parameter {
    /// <p>The name of the parameter to assign a value to. This parameter name must match a named parameter in the pipeline definition.</p>
    #[serde(rename = "Name")]
    pub name: String,
    /// <p>The literal value for the parameter.</p>
    #[serde(rename = "Value")]
    pub value: String,
}

/// <p>Defines the possible values for categorical, continuous, and integer hyperparameters to be used by an algorithm.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ParameterRange {
    /// <p>A <code>CategoricalParameterRangeSpecification</code> object that defines the possible values for a categorical hyperparameter.</p>
    #[serde(rename = "CategoricalParameterRangeSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub categorical_parameter_range_specification: Option<CategoricalParameterRangeSpecification>,
    /// <p>A <code>ContinuousParameterRangeSpecification</code> object that defines the possible values for a continuous hyperparameter.</p>
    #[serde(rename = "ContinuousParameterRangeSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub continuous_parameter_range_specification: Option<ContinuousParameterRangeSpecification>,
    /// <p>A <code>IntegerParameterRangeSpecification</code> object that defines the possible values for an integer hyperparameter.</p>
    #[serde(rename = "IntegerParameterRangeSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub integer_parameter_range_specification: Option<IntegerParameterRangeSpecification>,
}

/// <p><p>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.</p> <note> <p>You can specify a maximum of 20 hyperparameters that a hyperparameter tuning job can search over. Every possible value of a categorical parameter range counts against this limit.</p> </note></p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ParameterRanges {
    /// <p>The array of <a>CategoricalParameterRange</a> objects that specify ranges of categorical hyperparameters that a hyperparameter tuning job searches.</p>
    #[serde(rename = "CategoricalParameterRanges")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub categorical_parameter_ranges: Option<Vec<CategoricalParameterRange>>,
    /// <p>The array of <a>ContinuousParameterRange</a> objects that specify ranges of continuous hyperparameters that a hyperparameter tuning job searches.</p>
    #[serde(rename = "ContinuousParameterRanges")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub continuous_parameter_ranges: Option<Vec<ContinuousParameterRange>>,
    /// <p>The array of <a>IntegerParameterRange</a> objects that specify ranges of integer hyperparameters that a hyperparameter tuning job searches.</p>
    #[serde(rename = "IntegerParameterRanges")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub integer_parameter_ranges: Option<Vec<IntegerParameterRange>>,
}

/// <p>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.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Parent {
    /// <p>The name of the experiment.</p>
    #[serde(rename = "ExperimentName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_name: Option<String>,
    /// <p>The name of the trial.</p>
    #[serde(rename = "TrialName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_name: Option<String>,
}

/// <p>A previously completed or stopped hyperparameter tuning job to be used as a starting point for a new hyperparameter tuning job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ParentHyperParameterTuningJob {
    /// <p>The name of the hyperparameter tuning job to be used as a starting point for a new hyperparameter tuning job.</p>
    #[serde(rename = "HyperParameterTuningJobName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hyper_parameter_tuning_job_name: Option<String>,
}

/// <p>A SageMaker Model Building Pipeline instance.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Pipeline {
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>The creation time of the pipeline.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>The time that the pipeline was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The time when the pipeline was last run.</p>
    #[serde(rename = "LastRunTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_run_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the pipeline.</p>
    #[serde(rename = "PipelineArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_arn: Option<String>,
    /// <p>The description of the pipeline.</p>
    #[serde(rename = "PipelineDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_description: Option<String>,
    /// <p>The display name of the pipeline.</p>
    #[serde(rename = "PipelineDisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_display_name: Option<String>,
    /// <p>The name of the pipeline.</p>
    #[serde(rename = "PipelineName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_name: Option<String>,
    /// <p>The status of the pipeline.</p>
    #[serde(rename = "PipelineStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_status: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the role that created the pipeline.</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
    /// <p>A list of tags that apply to the pipeline.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

/// <p>An execution of a pipeline.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PipelineExecution {
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>The creation time of the pipeline execution.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>The time that the pipeline execution was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the pipeline that was executed.</p>
    #[serde(rename = "PipelineArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_arn: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_arn: Option<String>,
    /// <p>The description of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_description: Option<String>,
    /// <p>The display name of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionDisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_display_name: Option<String>,
    /// <p>The status of the pipeline status.</p>
    #[serde(rename = "PipelineExecutionStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_status: Option<String>,
    /// <p>Contains a list of pipeline parameters. This list can be empty. </p>
    #[serde(rename = "PipelineParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_parameters: Option<Vec<Parameter>>,
}

/// <p>An execution of a step in a pipeline.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PipelineExecutionStep {
    /// <p>If this pipeline execution step was cached, details on the cache hit.</p>
    #[serde(rename = "CacheHitResult")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_hit_result: Option<CacheHitResult>,
    /// <p>The time that the step stopped executing.</p>
    #[serde(rename = "EndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub end_time: Option<f64>,
    /// <p>The reason why the step failed execution. This is only returned if the step failed its execution.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The metadata for the step execution.</p>
    #[serde(rename = "Metadata")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<PipelineExecutionStepMetadata>,
    /// <p>The time that the step started executing.</p>
    #[serde(rename = "StartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start_time: Option<f64>,
    /// <p>The name of the step that is executed.</p>
    #[serde(rename = "StepName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub step_name: Option<String>,
    /// <p>The status of the step execution.</p>
    #[serde(rename = "StepStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub step_status: Option<String>,
}

/// <p>Metadata for a step execution.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PipelineExecutionStepMetadata {
    /// <p>If this is a Condition step metadata object, details on the condition.</p>
    #[serde(rename = "Condition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub condition: Option<ConditionStepMetadata>,
    /// <p>Metadata for the Model step.</p>
    #[serde(rename = "Model")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model: Option<ModelStepMetadata>,
    /// <p>The Amazon Resource Name (ARN) of the processing job that was run by this step execution.</p>
    #[serde(rename = "ProcessingJob")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_job: Option<ProcessingJobStepMetadata>,
    /// <p>Metadata for the RegisterModel step.</p>
    #[serde(rename = "RegisterModel")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub register_model: Option<RegisterModelStepMetadata>,
    /// <p>The Amazon Resource Name (ARN) of the training job that was run by this step execution.</p>
    #[serde(rename = "TrainingJob")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_job: Option<TrainingJobStepMetadata>,
    /// <p>The Amazon Resource Name (ARN) of the transform job that was run by this step execution.</p>
    #[serde(rename = "TransformJob")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transform_job: Option<TransformJobStepMetadata>,
}

/// <p>A pipeline execution summary.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PipelineExecutionSummary {
    /// <p>The Amazon Resource Name (ARN) of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_arn: Option<String>,
    /// <p>The description of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_description: Option<String>,
    /// <p>The display name of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionDisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_display_name: Option<String>,
    /// <p>The status of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_status: Option<String>,
    /// <p>The start time of the pipeline execution.</p>
    #[serde(rename = "StartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start_time: Option<f64>,
}

/// <p>A summary of a pipeline.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PipelineSummary {
    /// <p>The creation time of the pipeline.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The last time that a pipeline execution began.</p>
    #[serde(rename = "LastExecutionTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_execution_time: Option<f64>,
    /// <p>The time that the pipeline was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p> The Amazon Resource Name (ARN) of the pipeline.</p>
    #[serde(rename = "PipelineArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_arn: Option<String>,
    /// <p>The description of the pipeline.</p>
    #[serde(rename = "PipelineDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_description: Option<String>,
    /// <p>The display name of the pipeline.</p>
    #[serde(rename = "PipelineDisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_display_name: Option<String>,
    /// <p>The name of the pipeline.</p>
    #[serde(rename = "PipelineName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_name: Option<String>,
    /// <p>The Amazon Resource Name (ARN) that the pipeline used to execute.</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
}

/// <p>Configuration for the cluster used to run a processing job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProcessingClusterConfig {
    /// <p>The number of ML compute instances to use in the processing job. For distributed processing jobs, specify a value greater than 1. The default value is 1.</p>
    #[serde(rename = "InstanceCount")]
    pub instance_count: i64,
    /// <p>The ML compute instance type for the processing job.</p>
    #[serde(rename = "InstanceType")]
    pub instance_type: String,
    /// <p>The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt data on the storage volume attached to the ML compute instance(s) that run the processing job. </p>
    #[serde(rename = "VolumeKmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume_kms_key_id: Option<String>,
    /// <p>The size of the ML storage volume in gigabytes that you want to provision. You must specify sufficient ML storage for your scenario.</p>
    #[serde(rename = "VolumeSizeInGB")]
    pub volume_size_in_gb: i64,
}

/// <p>Configuration for processing job outputs in Amazon SageMaker Feature Store.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProcessingFeatureStoreOutput {
    /// <p>The name of the Amazon SageMaker FeatureGroup to use as the destination for processing job output.</p>
    #[serde(rename = "FeatureGroupName")]
    pub feature_group_name: String,
}

/// <p>The inputs for a processing job. The processing input must specify exactly one of either <code>S3Input</code> or <code>DatasetDefinition</code> types.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProcessingInput {
    /// <p>When <code>True</code>, input operations such as data download are managed natively by the processing job application. When <code>False</code> (default), input operations are managed by Amazon SageMaker.</p>
    #[serde(rename = "AppManaged")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_managed: Option<bool>,
    /// <p>Configuration for a Dataset Definition input. </p>
    #[serde(rename = "DatasetDefinition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dataset_definition: Option<DatasetDefinition>,
    /// <p>The name of the inputs for the processing job.</p>
    #[serde(rename = "InputName")]
    pub input_name: String,
    /// <p>Configuration for processing job inputs in Amazon S3.</p>
    #[serde(rename = "S3Input")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_input: Option<ProcessingS3Input>,
}

/// <p>An Amazon SageMaker processing job that is used to analyze data and evaluate models. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html">Process Data and Evaluate Models</a>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProcessingJob {
    #[serde(rename = "AppSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_specification: Option<AppSpecification>,
    /// <p>The Amazon Resource Name (ARN) of the AutoML job associated with this processing job.</p>
    #[serde(rename = "AutoMLJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_ml_job_arn: Option<String>,
    /// <p>The time the processing job was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>Sets the environment variables in the Docker container.</p>
    #[serde(rename = "Environment")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub environment: Option<::std::collections::HashMap<String, String>>,
    /// <p>A string, up to one KB in size, that contains metadata from the processing container when the processing job exits.</p>
    #[serde(rename = "ExitMessage")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub exit_message: Option<String>,
    #[serde(rename = "ExperimentConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_config: Option<ExperimentConfig>,
    /// <p>A string, up to one KB in size, that contains the reason a processing job failed, if it failed.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The time the processing job was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The ARN of a monitoring schedule for an endpoint associated with this processing job.</p>
    #[serde(rename = "MonitoringScheduleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitoring_schedule_arn: Option<String>,
    #[serde(rename = "NetworkConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub network_config: Option<NetworkConfig>,
    /// <p>The time that the processing job ended.</p>
    #[serde(rename = "ProcessingEndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_end_time: Option<f64>,
    /// <p>List of input configurations for the processing job.</p>
    #[serde(rename = "ProcessingInputs")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_inputs: Option<Vec<ProcessingInput>>,
    /// <p>The ARN of the processing job.</p>
    #[serde(rename = "ProcessingJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_job_arn: Option<String>,
    /// <p>The name of the processing job.</p>
    #[serde(rename = "ProcessingJobName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_job_name: Option<String>,
    /// <p>The status of the processing job.</p>
    #[serde(rename = "ProcessingJobStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_job_status: Option<String>,
    #[serde(rename = "ProcessingOutputConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_output_config: Option<ProcessingOutputConfig>,
    #[serde(rename = "ProcessingResources")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_resources: Option<ProcessingResources>,
    /// <p>The time that the processing job started.</p>
    #[serde(rename = "ProcessingStartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_start_time: Option<f64>,
    /// <p>The ARN of the role used to create the processing job.</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
    #[serde(rename = "StoppingCondition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopping_condition: Option<ProcessingStoppingCondition>,
    /// <p>An array of key-value pairs. For more information, see <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-whatURL">Using Cost Allocation Tags</a> in the <i>AWS Billing and Cost Management User Guide</i>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>The ARN of the training job associated with this processing job.</p>
    #[serde(rename = "TrainingJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_job_arn: Option<String>,
}

/// <p>Metadata for a processing job step.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProcessingJobStepMetadata {
    /// <p>The Amazon Resource Name (ARN) of the processing job.</p>
    #[serde(rename = "Arn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub arn: Option<String>,
}

/// <p>Summary of information about a processing job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProcessingJobSummary {
    /// <p>The time at which the processing job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>An optional string, up to one KB in size, that contains metadata from the processing container when the processing job exits.</p>
    #[serde(rename = "ExitMessage")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub exit_message: Option<String>,
    /// <p>A string, up to one KB in size, that contains the reason a processing job failed, if it failed.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>A timestamp that indicates the last time the processing job was modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The time at which the processing job completed.</p>
    #[serde(rename = "ProcessingEndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_end_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the processing job..</p>
    #[serde(rename = "ProcessingJobArn")]
    pub processing_job_arn: String,
    /// <p>The name of the processing job.</p>
    #[serde(rename = "ProcessingJobName")]
    pub processing_job_name: String,
    /// <p>The status of the processing job.</p>
    #[serde(rename = "ProcessingJobStatus")]
    pub processing_job_status: String,
}

/// <p>Describes the results of a processing job. The processing output must specify exactly one of either <code>S3Output</code> or <code>FeatureStoreOutput</code> types.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProcessingOutput {
    /// <p>When <code>True</code>, output operations such as data upload are managed natively by the processing job application. When <code>False</code> (default), output operations are managed by Amazon SageMaker.</p>
    #[serde(rename = "AppManaged")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_managed: Option<bool>,
    /// <p>Configuration for processing job outputs in Amazon SageMaker Feature Store. This processing output type is only supported when <code>AppManaged</code> is specified. </p>
    #[serde(rename = "FeatureStoreOutput")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub feature_store_output: Option<ProcessingFeatureStoreOutput>,
    /// <p>The name for the processing job output.</p>
    #[serde(rename = "OutputName")]
    pub output_name: String,
    /// <p>Configuration for processing job outputs in Amazon S3.</p>
    #[serde(rename = "S3Output")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_output: Option<ProcessingS3Output>,
}

/// <p>The output configuration for the processing job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProcessingOutputConfig {
    /// <p>The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt the processing job output. <code>KmsKeyId</code> can be an ID of a KMS key, ARN of a KMS key, alias of a KMS key, or alias of a KMS key. The <code>KmsKeyId</code> is applied to all outputs.</p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>List of output configurations for the processing job.</p>
    #[serde(rename = "Outputs")]
    pub outputs: Vec<ProcessingOutput>,
}

/// <p>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.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProcessingResources {
    /// <p>The configuration for the resources in a cluster used to run the processing job.</p>
    #[serde(rename = "ClusterConfig")]
    pub cluster_config: ProcessingClusterConfig,
}

/// <p>Configuration for processing job inputs in Amazon S3.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProcessingS3Input {
    /// <p>The local path to the Amazon S3 bucket where you want Amazon SageMaker to download the inputs to run a processing job. <code>LocalPath</code> is an absolute path to the input data. This is a required parameter when <code>AppManaged</code> is <code>False</code> (default).</p>
    #[serde(rename = "LocalPath")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub local_path: Option<String>,
    /// <p>Whether to use <code>Gzip</code> compression for Amazon S3 storage.</p>
    #[serde(rename = "S3CompressionType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_compression_type: Option<String>,
    /// <p>Whether the data stored in Amazon S3 is <code>FullyReplicated</code> or <code>ShardedByS3Key</code>.</p>
    #[serde(rename = "S3DataDistributionType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_data_distribution_type: Option<String>,
    /// <p>Whether you use an <code>S3Prefix</code> or a <code>ManifestFile</code> for the data type. If you choose <code>S3Prefix</code>, <code>S3Uri</code> identifies a key name prefix. Amazon SageMaker uses all objects with the specified key name prefix for the processing job. If you choose <code>ManifestFile</code>, <code>S3Uri</code> identifies an object that is a manifest file containing a list of object keys that you want Amazon SageMaker to use for the processing job.</p>
    #[serde(rename = "S3DataType")]
    pub s3_data_type: String,
    /// <p>Whether to use <code>File</code> or <code>Pipe</code> input mode. In <code>File</code> mode, Amazon SageMaker copies the data from the input source onto the local Amazon Elastic Block Store (Amazon EBS) volumes before starting your training algorithm. This is the most commonly used input mode. In <code>Pipe</code> mode, Amazon SageMaker streams input data from the source directly to your algorithm without using the EBS volume.This is a required parameter when <code>AppManaged</code> is <code>False</code> (default).</p>
    #[serde(rename = "S3InputMode")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_input_mode: Option<String>,
    /// <p>The URI for the Amazon S3 storage where you want Amazon SageMaker to download the artifacts needed to run a processing job.</p>
    #[serde(rename = "S3Uri")]
    pub s3_uri: String,
}

/// <p>Configuration for processing job outputs in Amazon S3.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProcessingS3Output {
    /// <p>The local path to the Amazon S3 bucket where you want Amazon SageMaker to save the results of an processing job. <code>LocalPath</code> is an absolute path to the input data.</p>
    #[serde(rename = "LocalPath")]
    pub local_path: String,
    /// <p>Whether to upload the results of the processing job continuously or after the job completes.</p>
    #[serde(rename = "S3UploadMode")]
    pub s3_upload_mode: String,
    /// <p>A URI that identifies the Amazon S3 bucket where you want Amazon SageMaker to save the results of a processing job.</p>
    #[serde(rename = "S3Uri")]
    pub s3_uri: String,
}

/// <p>Specifies a time limit for how long the processing job is allowed to run.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProcessingStoppingCondition {
    /// <p>Specifies the maximum runtime in seconds.</p>
    #[serde(rename = "MaxRuntimeInSeconds")]
    pub max_runtime_in_seconds: i64,
}

/// <p>Identifies a model that you want to host and the resources to deploy for hosting it. If you are deploying multiple models, tell Amazon SageMaker how to distribute traffic among the models by specifying variant weights. </p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProductionVariant {
    /// <p>The size of the Elastic Inference (EI) instance to use for the production variant. EI instances provide on-demand GPU computing for inference. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/ei.html">Using Elastic Inference in Amazon SageMaker</a>.</p>
    #[serde(rename = "AcceleratorType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accelerator_type: Option<String>,
    /// <p>Number of instances to launch initially.</p>
    #[serde(rename = "InitialInstanceCount")]
    pub initial_instance_count: i64,
    /// <p>Determines initial traffic distribution among all of the models that you specify in the endpoint configuration. The traffic to a production variant is determined by the ratio of the <code>VariantWeight</code> to the sum of all <code>VariantWeight</code> values across all ProductionVariants. If unspecified, it defaults to 1.0. </p>
    #[serde(rename = "InitialVariantWeight")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub initial_variant_weight: Option<f32>,
    /// <p>The ML compute instance type.</p>
    #[serde(rename = "InstanceType")]
    pub instance_type: String,
    /// <p>The name of the model that you want to host. This is the name that you specified when creating the model.</p>
    #[serde(rename = "ModelName")]
    pub model_name: String,
    /// <p>The name of the production variant.</p>
    #[serde(rename = "VariantName")]
    pub variant_name: String,
}

/// <p>Describes weight and capacities for a production variant associated with an endpoint. If you sent a request to the <code>UpdateEndpointWeightsAndCapacities</code> API and the endpoint status is <code>Updating</code>, you get different desired and current values. </p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProductionVariantSummary {
    /// <p>The number of instances associated with the variant.</p>
    #[serde(rename = "CurrentInstanceCount")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub current_instance_count: Option<i64>,
    /// <p>The weight associated with the variant.</p>
    #[serde(rename = "CurrentWeight")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub current_weight: Option<f32>,
    /// <p>An array of <code>DeployedImage</code> objects that specify the Amazon EC2 Container Registry paths of the inference images deployed on instances of this <code>ProductionVariant</code>.</p>
    #[serde(rename = "DeployedImages")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deployed_images: Option<Vec<DeployedImage>>,
    /// <p>The number of instances requested in the <code>UpdateEndpointWeightsAndCapacities</code> request. </p>
    #[serde(rename = "DesiredInstanceCount")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub desired_instance_count: Option<i64>,
    /// <p>The requested weight, as specified in the <code>UpdateEndpointWeightsAndCapacities</code> request. </p>
    #[serde(rename = "DesiredWeight")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub desired_weight: Option<f32>,
    /// <p>The name of the variant.</p>
    #[serde(rename = "VariantName")]
    pub variant_name: String,
}

/// <p>Configuration information for Debugger system monitoring, framework profiling, and storage paths.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProfilerConfig {
    /// <p>A time interval for capturing system metrics in milliseconds. Available values are 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds. The default value is 500 milliseconds.</p>
    #[serde(rename = "ProfilingIntervalInMilliseconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub profiling_interval_in_milliseconds: Option<i64>,
    /// <p>Configuration information for capturing framework metrics. Available key strings for different profiling options are <code>DetailedProfilingConfig</code>, <code>PythonProfilingConfig</code>, and <code>DataLoaderProfilingConfig</code>. The following codes are configuration structures for the <code>ProfilingParameters</code> parameter. To learn more about how to configure the <code>ProfilingParameters</code> parameter, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-createtrainingjob-api.html">Use the SageMaker and Debugger Configuration API Operations to Create, Update, and Debug Your Training Job</a>. </p>
    #[serde(rename = "ProfilingParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub profiling_parameters: Option<::std::collections::HashMap<String, String>>,
    /// <p>Path to Amazon S3 storage location for system and framework metrics.</p>
    #[serde(rename = "S3OutputPath")]
    pub s3_output_path: String,
}

/// <p>Configuration information for updating the Debugger profile parameters, system and framework metrics configurations, and storage paths.</p>
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ProfilerConfigForUpdate {
    /// <p>To disable Debugger monitoring and profiling, set to <code>True</code>.</p>
    #[serde(rename = "DisableProfiler")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disable_profiler: Option<bool>,
    /// <p>A time interval for capturing system metrics in milliseconds. Available values are 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds. The default value is 500 milliseconds.</p>
    #[serde(rename = "ProfilingIntervalInMilliseconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub profiling_interval_in_milliseconds: Option<i64>,
    /// <p>Configuration information for capturing framework metrics. Available key strings for different profiling options are <code>DetailedProfilingConfig</code>, <code>PythonProfilingConfig</code>, and <code>DataLoaderProfilingConfig</code>. The following codes are configuration structures for the <code>ProfilingParameters</code> parameter. To learn more about how to configure the <code>ProfilingParameters</code> parameter, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-createtrainingjob-api.html">Use the SageMaker and Debugger Configuration API Operations to Create, Update, and Debug Your Training Job</a>. </p>
    #[serde(rename = "ProfilingParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub profiling_parameters: Option<::std::collections::HashMap<String, String>>,
    /// <p>Path to Amazon S3 storage location for system and framework metrics.</p>
    #[serde(rename = "S3OutputPath")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_output_path: Option<String>,
}

/// <p>Configuration information for profiling rules.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProfilerRuleConfiguration {
    /// <p>The instance type to deploy a Debugger custom rule for profiling a training job.</p>
    #[serde(rename = "InstanceType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub instance_type: Option<String>,
    /// <p>Path to local storage location for output of rules. Defaults to <code>/opt/ml/processing/output/rule/</code>. </p>
    #[serde(rename = "LocalPath")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub local_path: Option<String>,
    /// <p>The name of the rule configuration. It must be unique relative to other rule configuration names.</p>
    #[serde(rename = "RuleConfigurationName")]
    pub rule_configuration_name: String,
    /// <p>The Amazon Elastic Container (ECR) Image for the managed rule evaluation.</p>
    #[serde(rename = "RuleEvaluatorImage")]
    pub rule_evaluator_image: String,
    /// <p>Runtime configuration for rule container.</p>
    #[serde(rename = "RuleParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rule_parameters: Option<::std::collections::HashMap<String, String>>,
    /// <p>Path to Amazon S3 storage location for rules.</p>
    #[serde(rename = "S3OutputPath")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_output_path: Option<String>,
    /// <p>The size, in GB, of the ML storage volume attached to the processing instance.</p>
    #[serde(rename = "VolumeSizeInGB")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume_size_in_gb: Option<i64>,
}

/// <p>Information about the status of the rule evaluation.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProfilerRuleEvaluationStatus {
    /// <p>Timestamp when the rule evaluation status was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The name of the rule configuration.</p>
    #[serde(rename = "RuleConfigurationName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rule_configuration_name: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the rule evaluation job.</p>
    #[serde(rename = "RuleEvaluationJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rule_evaluation_job_arn: Option<String>,
    /// <p>Status of the rule evaluation.</p>
    #[serde(rename = "RuleEvaluationStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rule_evaluation_status: Option<String>,
    /// <p>Details from the rule evaluation.</p>
    #[serde(rename = "StatusDetails")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_details: Option<String>,
}

/// <p>Information about a project.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProjectSummary {
    /// <p>The time that the project was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>The Amazon Resource Name (ARN) of the project.</p>
    #[serde(rename = "ProjectArn")]
    pub project_arn: String,
    /// <p>The description of the project.</p>
    #[serde(rename = "ProjectDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub project_description: Option<String>,
    /// <p>The ID of the project.</p>
    #[serde(rename = "ProjectId")]
    pub project_id: String,
    /// <p>The name of the project.</p>
    #[serde(rename = "ProjectName")]
    pub project_name: String,
    /// <p>The status of the project.</p>
    #[serde(rename = "ProjectStatus")]
    pub project_status: String,
}

/// <p>Part of the <code>SuggestionQuery</code> type. Specifies a hint for retrieving property names that begin with the specified text.</p>
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PropertyNameQuery {
    /// <p>Text that begins a property's name.</p>
    #[serde(rename = "PropertyNameHint")]
    pub property_name_hint: String,
}

/// <p>A property name returned from a <code>GetSearchSuggestions</code> call that specifies a value in the <code>PropertyNameQuery</code> field.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PropertyNameSuggestion {
    /// <p>A suggested property name based on what you entered in the search textbox in the Amazon SageMaker console.</p>
    #[serde(rename = "PropertyName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub property_name: Option<String>,
}

/// <p>A key value pair used when you provision a project as a service catalog product. For information, see <a href="https://docs.aws.amazon.com/servicecatalog/latest/adminguide/introduction.html">What is AWS Service Catalog</a>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProvisioningParameter {
    /// <p>The key that identifies a provisioning parameter.</p>
    #[serde(rename = "Key")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub key: Option<String>,
    /// <p>The value of the provisioning parameter.</p>
    #[serde(rename = "Value")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
}

/// <p><p>Defines the amount of money paid to an Amazon Mechanical Turk worker for each task performed. </p> <p>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.</p> <ul> <li> <p>0.036</p> </li> <li> <p>0.048</p> </li> <li> <p>0.060</p> </li> <li> <p>0.072</p> </li> <li> <p>0.120</p> </li> <li> <p>0.240</p> </li> <li> <p>0.360</p> </li> <li> <p>0.480</p> </li> <li> <p>0.600</p> </li> <li> <p>0.720</p> </li> <li> <p>0.840</p> </li> <li> <p>0.960</p> </li> <li> <p>1.080</p> </li> <li> <p>1.200</p> </li> </ul> <p>Use one of the following prices for image classification, text classification, and custom tasks. Prices are in US dollars.</p> <ul> <li> <p>0.012</p> </li> <li> <p>0.024</p> </li> <li> <p>0.036</p> </li> <li> <p>0.048</p> </li> <li> <p>0.060</p> </li> <li> <p>0.072</p> </li> <li> <p>0.120</p> </li> <li> <p>0.240</p> </li> <li> <p>0.360</p> </li> <li> <p>0.480</p> </li> <li> <p>0.600</p> </li> <li> <p>0.720</p> </li> <li> <p>0.840</p> </li> <li> <p>0.960</p> </li> <li> <p>1.080</p> </li> <li> <p>1.200</p> </li> </ul> <p>Use one of the following prices for semantic segmentation tasks. Prices are in US dollars.</p> <ul> <li> <p>0.840</p> </li> <li> <p>0.960</p> </li> <li> <p>1.080</p> </li> <li> <p>1.200</p> </li> </ul> <p>Use one of the following prices for Textract AnalyzeDocument Important Form Key Amazon Augmented AI review tasks. Prices are in US dollars.</p> <ul> <li> <p>2.400 </p> </li> <li> <p>2.280 </p> </li> <li> <p>2.160 </p> </li> <li> <p>2.040 </p> </li> <li> <p>1.920 </p> </li> <li> <p>1.800 </p> </li> <li> <p>1.680 </p> </li> <li> <p>1.560 </p> </li> <li> <p>1.440 </p> </li> <li> <p>1.320 </p> </li> <li> <p>1.200 </p> </li> <li> <p>1.080 </p> </li> <li> <p>0.960 </p> </li> <li> <p>0.840 </p> </li> <li> <p>0.720 </p> </li> <li> <p>0.600 </p> </li> <li> <p>0.480 </p> </li> <li> <p>0.360 </p> </li> <li> <p>0.240 </p> </li> <li> <p>0.120 </p> </li> <li> <p>0.072 </p> </li> <li> <p>0.060 </p> </li> <li> <p>0.048 </p> </li> <li> <p>0.036 </p> </li> <li> <p>0.024 </p> </li> <li> <p>0.012 </p> </li> </ul> <p>Use one of the following prices for Rekognition DetectModerationLabels Amazon Augmented AI review tasks. Prices are in US dollars.</p> <ul> <li> <p>1.200 </p> </li> <li> <p>1.080 </p> </li> <li> <p>0.960 </p> </li> <li> <p>0.840 </p> </li> <li> <p>0.720 </p> </li> <li> <p>0.600 </p> </li> <li> <p>0.480 </p> </li> <li> <p>0.360 </p> </li> <li> <p>0.240 </p> </li> <li> <p>0.120 </p> </li> <li> <p>0.072 </p> </li> <li> <p>0.060 </p> </li> <li> <p>0.048 </p> </li> <li> <p>0.036 </p> </li> <li> <p>0.024 </p> </li> <li> <p>0.012 </p> </li> </ul> <p>Use one of the following prices for Amazon Augmented AI custom human review tasks. Prices are in US dollars.</p> <ul> <li> <p>1.200 </p> </li> <li> <p>1.080 </p> </li> <li> <p>0.960 </p> </li> <li> <p>0.840 </p> </li> <li> <p>0.720 </p> </li> <li> <p>0.600 </p> </li> <li> <p>0.480 </p> </li> <li> <p>0.360 </p> </li> <li> <p>0.240 </p> </li> <li> <p>0.120 </p> </li> <li> <p>0.072 </p> </li> <li> <p>0.060 </p> </li> <li> <p>0.048 </p> </li> <li> <p>0.036 </p> </li> <li> <p>0.024 </p> </li> <li> <p>0.012 </p> </li> </ul></p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct PublicWorkforceTaskPrice {
    /// <p>Defines the amount of money paid to an Amazon Mechanical Turk worker in United States dollars.</p>
    #[serde(rename = "AmountInUsd")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub amount_in_usd: Option<USD>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutModelPackageGroupPolicyInput {
    /// <p>The name of the model group to add a resource policy to.</p>
    #[serde(rename = "ModelPackageGroupName")]
    pub model_package_group_name: String,
    /// <p>The resource policy for the model group.</p>
    #[serde(rename = "ResourcePolicy")]
    pub resource_policy: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutModelPackageGroupPolicyOutput {
    /// <p>The Amazon Resource Name (ARN) of the model package group.</p>
    #[serde(rename = "ModelPackageGroupArn")]
    pub model_package_group_arn: String,
}

/// <p>Configuration for Redshift Dataset Definition input.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RedshiftDatasetDefinition {
    #[serde(rename = "ClusterId")]
    pub cluster_id: String,
    /// <p>The IAM role attached to your Redshift cluster that Amazon SageMaker uses to generate datasets.</p>
    #[serde(rename = "ClusterRoleArn")]
    pub cluster_role_arn: String,
    #[serde(rename = "Database")]
    pub database: String,
    #[serde(rename = "DbUser")]
    pub db_user: String,
    /// <p>The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt data from a Redshift execution.</p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    #[serde(rename = "OutputCompression")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_compression: Option<String>,
    #[serde(rename = "OutputFormat")]
    pub output_format: String,
    /// <p>The location in Amazon S3 where the Redshift query results are stored.</p>
    #[serde(rename = "OutputS3Uri")]
    pub output_s3_uri: String,
    #[serde(rename = "QueryString")]
    pub query_string: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RegisterDevicesRequest {
    /// <p>The name of the fleet.</p>
    #[serde(rename = "DeviceFleetName")]
    pub device_fleet_name: String,
    /// <p>A list of devices to register with SageMaker Edge Manager.</p>
    #[serde(rename = "Devices")]
    pub devices: Vec<Device>,
    /// <p>The tags associated with devices.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
}

/// <p>Metadata for a register model job step.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RegisterModelStepMetadata {
    /// <p>The Amazon Resource Name (ARN) of the model package.</p>
    #[serde(rename = "Arn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RenderUiTemplateRequest {
    /// <p>The <code>HumanTaskUiArn</code> of the worker UI that you want to render. Do not provide a <code>HumanTaskUiArn</code> if you use the <code>UiTemplate</code> parameter.</p> <p>See a list of available Human Ui Amazon Resource Names (ARNs) in <a>UiConfig</a>.</p>
    #[serde(rename = "HumanTaskUiArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub human_task_ui_arn: Option<String>,
    /// <p>The Amazon Resource Name (ARN) that has access to the S3 objects that are used by the template.</p>
    #[serde(rename = "RoleArn")]
    pub role_arn: String,
    /// <p>A <code>RenderableTask</code> object containing a representative task to render.</p>
    #[serde(rename = "Task")]
    pub task: RenderableTask,
    /// <p>A <code>Template</code> object containing the worker UI template to render.</p>
    #[serde(rename = "UiTemplate")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ui_template: Option<UiTemplate>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RenderUiTemplateResponse {
    /// <p>A list of one or more <code>RenderingError</code> objects if any were encountered while rendering the template. If there were no errors, the list is empty.</p>
    #[serde(rename = "Errors")]
    pub errors: Vec<RenderingError>,
    /// <p>A Liquid template that renders the HTML for the worker UI.</p>
    #[serde(rename = "RenderedContent")]
    pub rendered_content: String,
}

/// <p>Contains input values for a task.</p>
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RenderableTask {
    /// <p>A JSON object that contains values for the variables defined in the template. It is made available to the template under the substitution variable <code>task.input</code>. For example, if you define a variable <code>task.input.text</code> in your template, you can supply the variable in the JSON object as <code>"text": "sample text"</code>.</p>
    #[serde(rename = "Input")]
    pub input: String,
}

/// <p>A description of an error that occurred while rendering the template.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RenderingError {
    /// <p>A unique identifier for a specific class of errors.</p>
    #[serde(rename = "Code")]
    pub code: String,
    /// <p>A human-readable message describing the error.</p>
    #[serde(rename = "Message")]
    pub message: String,
}

/// <p>The resolved attributes.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResolvedAttributes {
    #[serde(rename = "AutoMLJobObjective")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_ml_job_objective: Option<AutoMLJobObjective>,
    #[serde(rename = "CompletionCriteria")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub completion_criteria: Option<AutoMLJobCompletionCriteria>,
    /// <p>The problem type.</p>
    #[serde(rename = "ProblemType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub problem_type: Option<String>,
}

/// <p>Describes the resources, including ML compute instances and ML storage volumes, to use for model training. </p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ResourceConfig {
    /// <p>The number of ML compute instances to use. For distributed training, provide a value greater than 1. </p>
    #[serde(rename = "InstanceCount")]
    pub instance_count: i64,
    /// <p>The ML compute instance type. </p>
    #[serde(rename = "InstanceType")]
    pub instance_type: String,
    /// <p><p>The AWS KMS key that Amazon SageMaker uses to encrypt data on the storage volume attached to the ML compute instance(s) that run the training job.</p> <note> <p>Certain Nitro-based instances include local storage, dependent on the instance type. Local storage volumes are encrypted using a hardware module on the instance. You can&#39;t request a <code>VolumeKmsKeyId</code> when using an instance type with local storage.</p> <p>For a list of instance types that support local instance storage, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html#instance-store-volumes">Instance Store Volumes</a>.</p> <p>For more information about local instance storage encryption, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ssd-instance-store.html">SSD Instance Store Volumes</a>.</p> </note> <p>The <code>VolumeKmsKeyId</code> can be in any of the following formats:</p> <ul> <li> <p>// KMS Key ID</p> <p> <code>&quot;1234abcd-12ab-34cd-56ef-1234567890ab&quot;</code> </p> </li> <li> <p>// Amazon Resource Name (ARN) of a KMS Key</p> <p> <code>&quot;arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab&quot;</code> </p> </li> </ul></p>
    #[serde(rename = "VolumeKmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume_kms_key_id: Option<String>,
    /// <p><p>The size of the ML storage volume that you want to provision. </p> <p>ML storage volumes store model artifacts and incremental states. Training algorithms might also use the ML storage volume for scratch space. If you want to store the training data in the ML storage volume, choose <code>File</code> as the <code>TrainingInputMode</code> in the algorithm specification. </p> <p>You must specify sufficient ML storage for your scenario. </p> <note> <p> Amazon SageMaker supports only the General Purpose SSD (gp2) ML storage volume type. </p> </note> <note> <p>Certain Nitro-based instances include local storage with a fixed total size, dependent on the instance type. When using these instances for training, Amazon SageMaker mounts the local instance storage instead of Amazon EBS gp2 storage. You can&#39;t request a <code>VolumeSizeInGB</code> greater than the total size of the local instance storage.</p> <p>For a list of instance types that support local instance storage, including the total size per instance type, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html#instance-store-volumes">Instance Store Volumes</a>.</p> </note></p>
    #[serde(rename = "VolumeSizeInGB")]
    pub volume_size_in_gb: i64,
}

/// <p>Specifies the maximum number of training jobs and parallel training jobs that a hyperparameter tuning job can launch.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ResourceLimits {
    /// <p>The maximum number of training jobs that a hyperparameter tuning job can launch.</p>
    #[serde(rename = "MaxNumberOfTrainingJobs")]
    pub max_number_of_training_jobs: i64,
    /// <p>The maximum number of concurrent training jobs that a hyperparameter tuning job can launch.</p>
    #[serde(rename = "MaxParallelTrainingJobs")]
    pub max_parallel_training_jobs: i64,
}

/// <p>Specifies the ARN's of a SageMaker image and SageMaker image version, and the instance type that the version runs on.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ResourceSpec {
    /// <p>The instance type that the image version runs on.</p>
    #[serde(rename = "InstanceType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub instance_type: Option<String>,
    /// <p>The ARN of the SageMaker image that the image version belongs to.</p>
    #[serde(rename = "SageMakerImageArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sage_maker_image_arn: Option<String>,
    /// <p>The ARN of the image version created on the instance.</p>
    #[serde(rename = "SageMakerImageVersionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sage_maker_image_version_arn: Option<String>,
}

/// <p>The retention policy for data stored on an Amazon Elastic File System (EFS) volume.</p>
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RetentionPolicy {
    /// <p>The default is <code>Retain</code>, which specifies to keep the data stored on the EFS volume.</p> <p>Specify <code>Delete</code> to delete the data stored on the EFS volume.</p>
    #[serde(rename = "HomeEfsFileSystem")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub home_efs_file_system: Option<String>,
}

/// <p>Describes the S3 data source.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct S3DataSource {
    /// <p>A list of one or more attribute names to use that are found in a specified augmented manifest file.</p>
    #[serde(rename = "AttributeNames")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub attribute_names: Option<Vec<String>>,
    /// <p>If you want Amazon SageMaker to replicate the entire dataset on each ML compute instance that is launched for model training, specify <code>FullyReplicated</code>. </p> <p>If you want Amazon SageMaker to replicate a subset of data on each ML compute instance that is launched for model training, specify <code>ShardedByS3Key</code>. If there are <i>n</i> ML compute instances launched for a training job, each instance gets approximately 1/<i>n</i> of the number of S3 objects. In this case, model training on each machine uses only the subset of training data. </p> <p>Don't choose more ML compute instances for training than available S3 objects. If you do, some nodes won't get any data and you will pay for nodes that aren't getting any training data. This applies in both File and Pipe modes. Keep this in mind when developing algorithms. </p> <p>In distributed training, where you use multiple ML compute EC2 instances, you might choose <code>ShardedByS3Key</code>. If the algorithm requires copying training data to the ML storage volume (when <code>TrainingInputMode</code> is set to <code>File</code>), this copies 1/<i>n</i> of the number of objects. </p>
    #[serde(rename = "S3DataDistributionType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_data_distribution_type: Option<String>,
    /// <p>If you choose <code>S3Prefix</code>, <code>S3Uri</code> identifies a key name prefix. Amazon SageMaker uses all objects that match the specified key name prefix for model training. </p> <p>If you choose <code>ManifestFile</code>, <code>S3Uri</code> identifies an object that is a manifest file containing a list of object keys that you want Amazon SageMaker to use for model training. </p> <p>If you choose <code>AugmentedManifestFile</code>, S3Uri identifies an object that is an augmented manifest file in JSON lines format. This file contains the data you want to use for model training. <code>AugmentedManifestFile</code> can only be used if the Channel's input mode is <code>Pipe</code>.</p>
    #[serde(rename = "S3DataType")]
    pub s3_data_type: String,
    /// <p><p>Depending on the value specified for the <code>S3DataType</code>, identifies either a key name prefix or a manifest. For example: </p> <ul> <li> <p> A key name prefix might look like this: <code>s3://bucketname/exampleprefix</code> </p> </li> <li> <p> A manifest might look like this: <code>s3://bucketname/example.manifest</code> </p> <p> A manifest is an S3 object which is a JSON file consisting of an array of elements. The first element is a prefix which is followed by one or more suffixes. SageMaker appends the suffix elements to the prefix to get a full set of <code>S3Uri</code>. Note that the prefix must be a valid non-empty <code>S3Uri</code> that precludes users from specifying a manifest whose individual <code>S3Uri</code> is sourced from different S3 buckets.</p> <p> The following code example shows a valid manifest format: </p> <p> <code>[ {&quot;prefix&quot;: &quot;s3://customer<em>bucket/some/prefix/&quot;},</code> </p> <p> <code> &quot;relative/path/to/custdata-1&quot;,</code> </p> <p> <code> &quot;relative/path/custdata-2&quot;,</code> </p> <p> <code> ...</code> </p> <p> <code> &quot;relative/path/custdata-N&quot;</code> </p> <p> <code>]</code> </p> <p> This JSON is equivalent to the following <code>S3Uri</code> list:</p> <p> <code>s3://customer</em>bucket/some/prefix/relative/path/to/custdata-1</code> </p> <p> <code>s3://customer<em>bucket/some/prefix/relative/path/custdata-2</code> </p> <p> <code>...</code> </p> <p> <code>s3://customer</em>bucket/some/prefix/relative/path/custdata-N</code> </p> <p>The complete set of <code>S3Uri</code> in this manifest is the input data for the channel for this data source. The object that each <code>S3Uri</code> points to must be readable by the IAM role that Amazon SageMaker uses to perform tasks on your behalf. </p> </li> </ul></p>
    #[serde(rename = "S3Uri")]
    pub s3_uri: String,
}

/// <p>The Amazon Simple Storage (Amazon S3) location and and security configuration for <code>OfflineStore</code>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct S3StorageConfig {
    /// <p><p>The AWS Key Management Service (KMS) key ID of the key used to encrypt any objects written into the <code>OfflineStore</code> S3 location.</p> <p>The IAM <code>roleARN</code> that is passed as a parameter to <code>CreateFeatureGroup</code> must have below permissions to the <code>KmsKeyId</code>:</p> <ul> <li> <p> <code>&quot;kms:GenerateDataKey&quot;</code> </p> </li> </ul></p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>The S3 URI, or location in Amazon S3, of <code>OfflineStore</code>.</p> <p>S3 URIs have a format similar to the following: <code>s3://example-bucket/prefix/</code>.</p>
    #[serde(rename = "S3Uri")]
    pub s3_uri: String,
}

/// <p>Configuration details about the monitoring schedule.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ScheduleConfig {
    /// <p><p>A cron expression that describes details about the monitoring schedule.</p> <p>Currently the only supported cron expressions are:</p> <ul> <li> <p>If you want to set the job to start every hour, please use the following:</p> <p> <code>Hourly: cron(0 * ? * * *)</code> </p> </li> <li> <p>If you want to start the job daily:</p> <p> <code>cron(0 [00-23] ? * * *)</code> </p> </li> </ul> <p>For example, the following are valid cron expressions:</p> <ul> <li> <p>Daily at noon UTC: <code>cron(0 12 ? * * *)</code> </p> </li> <li> <p>Daily at midnight UTC: <code>cron(0 0 ? * * *)</code> </p> </li> </ul> <p>To support running every 6, 12 hours, the following are also supported:</p> <p> <code>cron(0 [00-23]/[01-24] ? * * *)</code> </p> <p>For example, the following are valid cron expressions:</p> <ul> <li> <p>Every 12 hours, starting at 5pm UTC: <code>cron(0 17/12 ? * * *)</code> </p> </li> <li> <p>Every two hours starting at midnight: <code>cron(0 0/2 ? * * *)</code> </p> </li> </ul> <note> <ul> <li> <p>Even though the cron expression is set to start at 5PM UTC, note that there could be a delay of 0-20 minutes from the actual requested time to run the execution. </p> </li> <li> <p>We recommend that if you would like a daily schedule, you do not provide this parameter. Amazon SageMaker will pick a time for running every day.</p> </li> </ul> </note></p>
    #[serde(rename = "ScheduleExpression")]
    pub schedule_expression: String,
}

/// <p><p>A multi-expression that searches for the specified resource or resources in a search. All resource objects that satisfy the expression&#39;s condition are included in the search results. You must specify at least one subexpression, filter, or nested filter. A <code>SearchExpression</code> can contain up to twenty elements.</p> <p>A <code>SearchExpression</code> contains the following components:</p> <ul> <li> <p>A list of <code>Filter</code> objects. Each filter defines a simple Boolean expression comprised of a resource property name, Boolean operator, and value.</p> </li> <li> <p>A list of <code>NestedFilter</code> objects. 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.</p> </li> <li> <p>A list of <code>SearchExpression</code> objects. A search expression object can be nested in a list of search expression objects.</p> </li> <li> <p>A Boolean operator: <code>And</code> or <code>Or</code>.</p> </li> </ul></p>
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SearchExpression {
    /// <p>A list of filter objects.</p>
    #[serde(rename = "Filters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filters: Option<Vec<Filter>>,
    /// <p>A list of nested filter objects.</p>
    #[serde(rename = "NestedFilters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nested_filters: Option<Vec<NestedFilters>>,
    /// <p>A Boolean operator used to evaluate the search expression. If you want every conditional statement in all lists to be satisfied for the entire search expression to be true, specify <code>And</code>. If only a single conditional statement needs to be true for the entire search expression to be true, specify <code>Or</code>. The default value is <code>And</code>.</p>
    #[serde(rename = "Operator")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub operator: Option<String>,
    /// <p>A list of search expression objects.</p>
    #[serde(rename = "SubExpressions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sub_expressions: Option<Vec<SearchExpression>>,
}

/// <p>A single resource returned as part of the <a>Search</a> API response.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SearchRecord {
    #[serde(rename = "Endpoint")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endpoint: Option<Endpoint>,
    /// <p>The properties of an experiment.</p>
    #[serde(rename = "Experiment")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment: Option<Experiment>,
    #[serde(rename = "FeatureGroup")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub feature_group: Option<FeatureGroup>,
    #[serde(rename = "ModelPackage")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package: Option<ModelPackage>,
    #[serde(rename = "ModelPackageGroup")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_package_group: Option<ModelPackageGroup>,
    #[serde(rename = "Pipeline")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline: Option<Pipeline>,
    #[serde(rename = "PipelineExecution")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution: Option<PipelineExecution>,
    /// <p>The properties of a training job.</p>
    #[serde(rename = "TrainingJob")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_job: Option<TrainingJob>,
    /// <p>The properties of a trial.</p>
    #[serde(rename = "Trial")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial: Option<Trial>,
    /// <p>The properties of a trial component.</p>
    #[serde(rename = "TrialComponent")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component: Option<TrialComponent>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SearchRequest {
    /// <p>The maximum number of results to return.</p>
    #[serde(rename = "MaxResults")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results: Option<i64>,
    /// <p>If more than <code>MaxResults</code> resources match the specified <code>SearchExpression</code>, the response includes a <code>NextToken</code>. The <code>NextToken</code> can be passed to the next <code>SearchRequest</code> to continue retrieving results.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>The name of the Amazon SageMaker resource to search for.</p>
    #[serde(rename = "Resource")]
    pub resource: String,
    /// <p>A Boolean conditional statement. Resources must satisfy this condition to be included in search results. You must provide at least one subexpression, filter, or nested filter. The maximum number of recursive <code>SubExpressions</code>, <code>NestedFilters</code>, and <code>Filters</code> that can be included in a <code>SearchExpression</code> object is 50.</p>
    #[serde(rename = "SearchExpression")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub search_expression: Option<SearchExpression>,
    /// <p>The name of the resource property used to sort the <code>SearchResults</code>. The default is <code>LastModifiedTime</code>.</p>
    #[serde(rename = "SortBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    /// <p>How <code>SearchResults</code> are ordered. Valid values are <code>Ascending</code> or <code>Descending</code>. The default is <code>Descending</code>.</p>
    #[serde(rename = "SortOrder")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_order: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SearchResponse {
    /// <p>If the result of the previous <code>Search</code> request was truncated, the response includes a NextToken. To retrieve the next set of results, use the token in the next request.</p>
    #[serde(rename = "NextToken")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_token: Option<String>,
    /// <p>A list of <code>SearchRecord</code> objects.</p>
    #[serde(rename = "Results")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub results: Option<Vec<SearchRecord>>,
}

/// <p><p>An array element of <a>DescribeTrainingJobResponse$SecondaryStatusTransitions</a>. 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, Amazon SageMaker could be starting the training job or launching the ML instances. These transitional states are referred to as the job&#39;s secondary status. </p> <p/></p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SecondaryStatusTransition {
    /// <p>A timestamp that shows when the training job transitioned out of this secondary status state into another secondary status state or when the training job has ended.</p>
    #[serde(rename = "EndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub end_time: Option<f64>,
    /// <p>A timestamp that shows when the training job transitioned to the current secondary status state.</p>
    #[serde(rename = "StartTime")]
    pub start_time: f64,
    /// <p><p>Contains a secondary status information from a training job.</p> <p>Status might be one of the following secondary statuses:</p> <dl> <dt>InProgress</dt> <dd> <ul> <li> <p> <code>Starting</code> - Starting the training job.</p> </li> <li> <p> <code>Downloading</code> - An optional stage for algorithms that support <code>File</code> training input mode. It indicates that data is being downloaded to the ML storage volumes.</p> </li> <li> <p> <code>Training</code> - Training is in progress.</p> </li> <li> <p> <code>Uploading</code> - Training is complete and the model artifacts are being uploaded to the S3 location.</p> </li> </ul> </dd> <dt>Completed</dt> <dd> <ul> <li> <p> <code>Completed</code> - The training job has completed.</p> </li> </ul> </dd> <dt>Failed</dt> <dd> <ul> <li> <p> <code>Failed</code> - The training job has failed. The reason for the failure is returned in the <code>FailureReason</code> field of <code>DescribeTrainingJobResponse</code>.</p> </li> </ul> </dd> <dt>Stopped</dt> <dd> <ul> <li> <p> <code>MaxRuntimeExceeded</code> - The job stopped because it exceeded the maximum allowed runtime.</p> </li> <li> <p> <code>Stopped</code> - The training job has stopped.</p> </li> </ul> </dd> <dt>Stopping</dt> <dd> <ul> <li> <p> <code>Stopping</code> - Stopping the training job.</p> </li> </ul> </dd> </dl> <p>We no longer support the following secondary statuses:</p> <ul> <li> <p> <code>LaunchingMLInstances</code> </p> </li> <li> <p> <code>PreparingTrainingStack</code> </p> </li> <li> <p> <code>DownloadingTrainingImage</code> </p> </li> </ul></p>
    #[serde(rename = "Status")]
    pub status: String,
    /// <p><p>A detailed description of the progress within a secondary status. </p> <p>Amazon SageMaker provides secondary statuses and status messages that apply to each of them:</p> <dl> <dt>Starting</dt> <dd> <ul> <li> <p>Starting the training job.</p> </li> <li> <p>Launching requested ML instances.</p> </li> <li> <p>Insufficient capacity error from EC2 while launching instances, retrying!</p> </li> <li> <p>Launched instance was unhealthy, replacing it!</p> </li> <li> <p>Preparing the instances for training.</p> </li> </ul> </dd> <dt>Training</dt> <dd> <ul> <li> <p>Downloading the training image.</p> </li> <li> <p>Training image download completed. Training in progress.</p> </li> </ul> </dd> </dl> <important> <p>Status messages are subject to change. Therefore, we recommend not including them in code that programmatically initiates actions. For examples, don&#39;t use status messages in if statements.</p> </important> <p>To have an overview of your training job&#39;s progress, view <code>TrainingJobStatus</code> and <code>SecondaryStatus</code> in <a>DescribeTrainingJob</a>, and <code>StatusMessage</code> together. For example, at the start of a training job, you might see the following:</p> <ul> <li> <p> <code>TrainingJobStatus</code> - InProgress</p> </li> <li> <p> <code>SecondaryStatus</code> - Training</p> </li> <li> <p> <code>StatusMessage</code> - Downloading the training image</p> </li> </ul></p>
    #[serde(rename = "StatusMessage")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_message: Option<String>,
}

/// <p>Details of a provisioned service catalog product. For information about service catalog, see <a href="https://docs.aws.amazon.com/servicecatalog/latest/adminguide/introduction.html">What is AWS Service Catalog</a>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ServiceCatalogProvisionedProductDetails {
    /// <p>The ID of the provisioned product.</p>
    #[serde(rename = "ProvisionedProductId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provisioned_product_id: Option<String>,
    /// <p><p>The current status of the product.</p> <ul> <li> <p> <code>AVAILABLE</code> - Stable state, ready to perform any operation. The most recent operation succeeded and completed.</p> </li> <li> <p> <code>UNDER<em>CHANGE</code> - Transitive state. Operations performed might not have valid results. Wait for an AVAILABLE status before performing operations.</p> </li> <li> <p> <code>TAINTED</code> - Stable state, ready to perform any operation. The stack has completed the requested operation but is not exactly what was requested. For example, a request to update to a new version failed and the stack rolled back to the current version.</p> </li> <li> <p> <code>ERROR</code> - An unexpected error occurred. The provisioned product exists but the stack is not running. For example, CloudFormation received a parameter value that was not valid and could not launch the stack.</p> </li> <li> <p> <code>PLAN</em>IN_PROGRESS</code> - Transitive state. The plan operations were performed to provision a new product, but resources have not yet been created. After reviewing the list of resources to be created, execute the plan. Wait for an AVAILABLE status before performing operations.</p> </li> </ul></p>
    #[serde(rename = "ProvisionedProductStatusMessage")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provisioned_product_status_message: Option<String>,
}

/// <p>Details that you specify to provision a service catalog product. For information about service catalog, see .<a href="https://docs.aws.amazon.com/servicecatalog/latest/adminguide/introduction.html">What is AWS Service Catalog</a>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ServiceCatalogProvisioningDetails {
    /// <p>The path identifier of the product. This value is optional if the product has a default path, and required if the product has more than one path. </p>
    #[serde(rename = "PathId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub path_id: Option<String>,
    /// <p>The ID of the product to provision.</p>
    #[serde(rename = "ProductId")]
    pub product_id: String,
    /// <p>The ID of the provisioning artifact.</p>
    #[serde(rename = "ProvisioningArtifactId")]
    pub provisioning_artifact_id: String,
    /// <p>A list of key value pairs that you specify when you provision a product.</p>
    #[serde(rename = "ProvisioningParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provisioning_parameters: Option<Vec<ProvisioningParameter>>,
}

/// <p>Specifies options when sharing an Amazon SageMaker Studio notebook. These settings are specified as part of <code>DefaultUserSettings</code> when the <a>CreateDomain</a> API is called, and as part of <code>UserSettings</code> when the <a>CreateUserProfile</a> API is called.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SharingSettings {
    /// <p>Whether to include the notebook cell output when sharing the notebook. The default is <code>Disabled</code>.</p>
    #[serde(rename = "NotebookOutputOption")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_output_option: Option<String>,
    /// <p>When <code>NotebookOutputOption</code> is <code>Allowed</code>, the AWS Key Management Service (KMS) encryption key ID used to encrypt the notebook cell output in the Amazon S3 bucket.</p>
    #[serde(rename = "S3KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_kms_key_id: Option<String>,
    /// <p>When <code>NotebookOutputOption</code> is <code>Allowed</code>, the Amazon S3 bucket used to save the notebook cell output.</p>
    #[serde(rename = "S3OutputPath")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s3_output_path: Option<String>,
}

/// <p>A configuration for a shuffle option for input data in a channel. If you use <code>S3Prefix</code> for <code>S3DataType</code>, the results of the S3 key prefix matches are shuffled. If you use <code>ManifestFile</code>, the order of the S3 object references in the <code>ManifestFile</code> is shuffled. If you use <code>AugmentedManifestFile</code>, the order of the JSON lines in the <code>AugmentedManifestFile</code> is shuffled. The shuffling order is determined using the <code>Seed</code> value.</p> <p>For Pipe input mode, when <code>ShuffleConfig</code> is 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 when <code>ShuffleConfig</code> is combined with <code>S3DataDistributionType</code> of <code>ShardedByS3Key</code>, 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.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ShuffleConfig {
    /// <p>Determines the shuffling order in <code>ShuffleConfig</code> value.</p>
    #[serde(rename = "Seed")]
    pub seed: i64,
}

/// <p>Specifies an algorithm that was used to create the model package. The algorithm must be either an algorithm resource in your Amazon SageMaker account or an algorithm in AWS Marketplace that you are subscribed to.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SourceAlgorithm {
    /// <p>The name of an algorithm that was used to create the model package. The algorithm must be either an algorithm resource in your Amazon SageMaker account or an algorithm in AWS Marketplace that you are subscribed to.</p>
    #[serde(rename = "AlgorithmName")]
    pub algorithm_name: String,
    /// <p><p>The Amazon S3 path where the model artifacts, which result from model training, are stored. This path must point to a single <code>gzip</code> compressed tar archive (<code>.tar.gz</code> suffix).</p> <note> <p>The model artifacts must be in an S3 bucket that is in the same region as the algorithm.</p> </note></p>
    #[serde(rename = "ModelDataUrl")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_data_url: Option<String>,
}

/// <p>A list of algorithms that were used to create a model package.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SourceAlgorithmSpecification {
    /// <p>A list of the algorithms that were used to create a model package.</p>
    #[serde(rename = "SourceAlgorithms")]
    pub source_algorithms: Vec<SourceAlgorithm>,
}

/// <p>A list of IP address ranges (<a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html">CIDRs</a>). Used to create an allow list of IP addresses for a private workforce. Workers will only be able to login to their worker portal from an IP address within this range. By default, a workforce isn't restricted to specific IP addresses.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SourceIpConfig {
    /// <p><p>A list of one to ten <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html">Classless Inter-Domain Routing</a> (CIDR) values.</p> <p>Maximum: Ten CIDR values</p> <note> <p>The following Length Constraints apply to individual CIDR values in the CIDR value list.</p> </note></p>
    #[serde(rename = "Cidrs")]
    pub cidrs: Vec<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartMonitoringScheduleRequest {
    /// <p>The name of the schedule to start.</p>
    #[serde(rename = "MonitoringScheduleName")]
    pub monitoring_schedule_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartNotebookInstanceInput {
    /// <p>The name of the notebook instance to start.</p>
    #[serde(rename = "NotebookInstanceName")]
    pub notebook_instance_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartPipelineExecutionRequest {
    /// <p>A unique, case-sensitive identifier that you provide to ensure the idempotency of the operation. An idempotent operation completes no more than one time.</p>
    #[serde(rename = "ClientRequestToken")]
    pub client_request_token: String,
    /// <p>The description of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_description: Option<String>,
    /// <p>The display name of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionDisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_display_name: Option<String>,
    /// <p>The name of the pipeline.</p>
    #[serde(rename = "PipelineName")]
    pub pipeline_name: String,
    /// <p>Contains a list of pipeline parameters. This list can be empty. </p>
    #[serde(rename = "PipelineParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_parameters: Option<Vec<Parameter>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartPipelineExecutionResponse {
    /// <p>The Amazon Resource Name (ARN) of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopAutoMLJobRequest {
    /// <p>The name of the object you are requesting.</p>
    #[serde(rename = "AutoMLJobName")]
    pub auto_ml_job_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopCompilationJobRequest {
    /// <p>The name of the model compilation job to stop.</p>
    #[serde(rename = "CompilationJobName")]
    pub compilation_job_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopEdgePackagingJobRequest {
    /// <p>The name of the edge packaging job.</p>
    #[serde(rename = "EdgePackagingJobName")]
    pub edge_packaging_job_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopHyperParameterTuningJobRequest {
    /// <p>The name of the tuning job to stop.</p>
    #[serde(rename = "HyperParameterTuningJobName")]
    pub hyper_parameter_tuning_job_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopLabelingJobRequest {
    /// <p>The name of the labeling job to stop.</p>
    #[serde(rename = "LabelingJobName")]
    pub labeling_job_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopMonitoringScheduleRequest {
    /// <p>The name of the schedule to stop.</p>
    #[serde(rename = "MonitoringScheduleName")]
    pub monitoring_schedule_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopNotebookInstanceInput {
    /// <p>The name of the notebook instance to terminate.</p>
    #[serde(rename = "NotebookInstanceName")]
    pub notebook_instance_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopPipelineExecutionRequest {
    /// <p>A unique, case-sensitive identifier that you provide to ensure the idempotency of the operation. An idempotent operation completes no more than one time.</p>
    #[serde(rename = "ClientRequestToken")]
    pub client_request_token: String,
    /// <p>The Amazon Resource Name (ARN) of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionArn")]
    pub pipeline_execution_arn: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopPipelineExecutionResponse {
    /// <p>The Amazon Resource Name (ARN) of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopProcessingJobRequest {
    /// <p>The name of the processing job to stop.</p>
    #[serde(rename = "ProcessingJobName")]
    pub processing_job_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopTrainingJobRequest {
    /// <p>The name of the training job to stop.</p>
    #[serde(rename = "TrainingJobName")]
    pub training_job_name: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopTransformJobRequest {
    /// <p>The name of the transform job to stop.</p>
    #[serde(rename = "TransformJobName")]
    pub transform_job_name: String,
}

/// <p><p>Specifies a limit to how long a model training or compilation job can run. It also specifies how long you are willing to wait for a managed spot training job to complete. When the job reaches the time limit, Amazon SageMaker ends the training or compilation job. Use this API to cap model training costs.</p> <p>To stop a job, Amazon SageMaker sends the algorithm the <code>SIGTERM</code> signal, 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. </p> <p>The training algorithms provided by Amazon 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 <code>CreateModel</code>.</p> <note> <p>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.</p> </note></p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct StoppingCondition {
    /// <p>The maximum length of time, in seconds, that the training or compilation job can run. If job does not complete during this time, Amazon SageMaker ends the job. If value is not specified, default value is 1 day. The maximum value is 28 days.</p>
    #[serde(rename = "MaxRuntimeInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_runtime_in_seconds: Option<i64>,
    /// <p>The maximum length of time, in seconds, how long you are willing to wait for a managed spot training job to complete. It is the amount of time spent waiting for Spot capacity plus the amount of time the training job runs. It must be equal to or greater than <code>MaxRuntimeInSeconds</code>. </p>
    #[serde(rename = "MaxWaitTimeInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_wait_time_in_seconds: Option<i64>,
}

/// <p>Describes a work team of a vendor that does the a labelling job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SubscribedWorkteam {
    /// <p>Marketplace product listing ID.</p>
    #[serde(rename = "ListingId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub listing_id: Option<String>,
    /// <p>The description of the vendor from the Amazon Marketplace.</p>
    #[serde(rename = "MarketplaceDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub marketplace_description: Option<String>,
    /// <p>The title of the service provided by the vendor in the Amazon Marketplace.</p>
    #[serde(rename = "MarketplaceTitle")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub marketplace_title: Option<String>,
    /// <p>The name of the vendor in the Amazon Marketplace.</p>
    #[serde(rename = "SellerName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seller_name: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the vendor that you have subscribed.</p>
    #[serde(rename = "WorkteamArn")]
    pub workteam_arn: String,
}

/// <p>Specified in the <a>GetSearchSuggestions</a> request. Limits the property names that are included in the response.</p>
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SuggestionQuery {
    /// <p>Defines a property name hint. Only property names that begin with the specified hint are included in the response.</p>
    #[serde(rename = "PropertyNameQuery")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub property_name_query: Option<PropertyNameQuery>,
}

/// <p>Describes a tag. </p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
    /// <p>The tag key.</p>
    #[serde(rename = "Key")]
    pub key: String,
    /// <p>The tag value.</p>
    #[serde(rename = "Value")]
    pub value: String,
}

/// <p>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 <code>TargetDevice</code>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TargetPlatform {
    /// <p><p>Specifies a target platform accelerator (optional).</p> <ul> <li> <p> <code>NVIDIA</code>: Nvidia graphics processing unit. It also requires <code>gpu-code</code>, <code>trt-ver</code>, <code>cuda-ver</code> compiler options</p> </li> <li> <p> <code>MALI</code>: ARM Mali graphics processor</p> </li> <li> <p> <code>INTEL_GRAPHICS</code>: Integrated Intel graphics</p> </li> </ul></p>
    #[serde(rename = "Accelerator")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accelerator: Option<String>,
    /// <p><p>Specifies a target platform architecture.</p> <ul> <li> <p> <code>X86<em>64</code>: 64-bit version of the x86 instruction set.</p> </li> <li> <p> <code>X86</code>: 32-bit version of the x86 instruction set.</p> </li> <li> <p> <code>ARM64</code>: ARMv8 64-bit CPU.</p> </li> <li> <p> <code>ARM</em>EABIHF</code>: ARMv7 32-bit, Hard Float.</p> </li> <li> <p> <code>ARM_EABI</code>: ARMv7 32-bit, Soft Float. Used by Android 32-bit ARM platform.</p> </li> </ul></p>
    #[serde(rename = "Arch")]
    pub arch: String,
    /// <p><p>Specifies a target platform OS.</p> <ul> <li> <p> <code>LINUX</code>: Linux-based operating systems.</p> </li> <li> <p> <code>ANDROID</code>: Android operating systems. Android API level can be specified using the <code>ANDROID<em>PLATFORM</code> compiler option. For example, <code>&quot;CompilerOptions&quot;: {&#39;ANDROID</em>PLATFORM&#39;: 28}</code> </p> </li> </ul></p>
    #[serde(rename = "Os")]
    pub os: String,
}

/// <p>The TensorBoard app settings.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TensorBoardAppSettings {
    /// <p>The default instance type and the Amazon Resource Name (ARN) of the SageMaker image created on the instance.</p>
    #[serde(rename = "DefaultResourceSpec")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_resource_spec: Option<ResourceSpec>,
}

/// <p>Configuration of storage locations for the Debugger TensorBoard output data.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TensorBoardOutputConfig {
    /// <p>Path to local storage location for tensorBoard output. Defaults to <code>/opt/ml/output/tensorboard</code>.</p>
    #[serde(rename = "LocalPath")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub local_path: Option<String>,
    /// <p>Path to Amazon S3 storage location for TensorBoard output.</p>
    #[serde(rename = "S3OutputPath")]
    pub s3_output_path: String,
}

/// <p>Currently, the <code>TrafficRoutingConfig</code> API is not supported.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TrafficRoutingConfig {
    /// <p><p/></p>
    #[serde(rename = "CanarySize")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub canary_size: Option<CapacitySize>,
    /// <p><p/></p>
    #[serde(rename = "Type")]
    pub type_: String,
    /// <p><p/></p>
    #[serde(rename = "WaitIntervalInSeconds")]
    pub wait_interval_in_seconds: i64,
}

/// <p>Contains information about a training job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TrainingJob {
    /// <p>Information about the algorithm used for training, and algorithm metadata.</p>
    #[serde(rename = "AlgorithmSpecification")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub algorithm_specification: Option<AlgorithmSpecification>,
    /// <p>The Amazon Resource Name (ARN) of the job.</p>
    #[serde(rename = "AutoMLJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_ml_job_arn: Option<String>,
    /// <p>The billable time in seconds.</p>
    #[serde(rename = "BillableTimeInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billable_time_in_seconds: Option<i64>,
    #[serde(rename = "CheckpointConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub checkpoint_config: Option<CheckpointConfig>,
    /// <p>A timestamp that indicates when the training job was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    #[serde(rename = "DebugHookConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub debug_hook_config: Option<DebugHookConfig>,
    /// <p>Information about the debug rule configuration.</p>
    #[serde(rename = "DebugRuleConfigurations")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub debug_rule_configurations: Option<Vec<DebugRuleConfiguration>>,
    /// <p>Information about the evaluation status of the rules for the training job.</p>
    #[serde(rename = "DebugRuleEvaluationStatuses")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub debug_rule_evaluation_statuses: Option<Vec<DebugRuleEvaluationStatus>>,
    /// <p>To encrypt all communications between ML compute instances in distributed training, choose <code>True</code>. Encryption provides greater security for distributed training, but training might take longer. How long it takes depends on the amount of communication between compute instances, especially if you use a deep learning algorithm in distributed training.</p>
    #[serde(rename = "EnableInterContainerTrafficEncryption")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_inter_container_traffic_encryption: Option<bool>,
    /// <p>When true, enables managed spot training using Amazon EC2 Spot instances to run training jobs instead of on-demand instances. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html">Managed Spot Training</a>.</p>
    #[serde(rename = "EnableManagedSpotTraining")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_managed_spot_training: Option<bool>,
    /// <p>If the <code>TrainingJob</code> was created with network isolation, the value is set to <code>true</code>. If network isolation is enabled, nodes can't communicate beyond the VPC they run in.</p>
    #[serde(rename = "EnableNetworkIsolation")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_network_isolation: Option<bool>,
    #[serde(rename = "ExperimentConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_config: Option<ExperimentConfig>,
    /// <p>If the training job failed, the reason it failed.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>A list of final metric values that are set when the training job completes. Used only if the training job was configured to use metrics.</p>
    #[serde(rename = "FinalMetricDataList")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub final_metric_data_list: Option<Vec<MetricData>>,
    /// <p>Algorithm-specific parameters.</p>
    #[serde(rename = "HyperParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hyper_parameters: Option<::std::collections::HashMap<String, String>>,
    /// <p>An array of <code>Channel</code> objects that describes each data input channel.</p>
    #[serde(rename = "InputDataConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_data_config: Option<Vec<Channel>>,
    /// <p>The Amazon Resource Name (ARN) of the labeling job.</p>
    #[serde(rename = "LabelingJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub labeling_job_arn: Option<String>,
    /// <p>A timestamp that indicates when the status of the training job was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>Information about the Amazon S3 location that is configured for storing model artifacts.</p>
    #[serde(rename = "ModelArtifacts")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_artifacts: Option<ModelArtifacts>,
    /// <p>The S3 path where model artifacts that you configured when creating the job are stored. Amazon SageMaker creates subfolders for model artifacts.</p>
    #[serde(rename = "OutputDataConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_data_config: Option<OutputDataConfig>,
    /// <p>Resources, including ML compute instances and ML storage volumes, that are configured for model training.</p>
    #[serde(rename = "ResourceConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resource_config: Option<ResourceConfig>,
    /// <p>The AWS Identity and Access Management (IAM) role configured for the training job.</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
    /// <p><p> Provides detailed information about the state of the training job. For detailed information about the secondary status of the training job, see <code>StatusMessage</code> under <a>SecondaryStatusTransition</a>.</p> <p>Amazon SageMaker provides primary statuses and secondary statuses that apply to each of them:</p> <dl> <dt>InProgress</dt> <dd> <ul> <li> <p> <code>Starting</code> - Starting the training job.</p> </li> <li> <p> <code>Downloading</code> - An optional stage for algorithms that support <code>File</code> training input mode. It indicates that data is being downloaded to the ML storage volumes.</p> </li> <li> <p> <code>Training</code> - Training is in progress.</p> </li> <li> <p> <code>Uploading</code> - Training is complete and the model artifacts are being uploaded to the S3 location.</p> </li> </ul> </dd> <dt>Completed</dt> <dd> <ul> <li> <p> <code>Completed</code> - The training job has completed.</p> </li> </ul> </dd> <dt>Failed</dt> <dd> <ul> <li> <p> <code>Failed</code> - The training job has failed. The reason for the failure is returned in the <code>FailureReason</code> field of <code>DescribeTrainingJobResponse</code>.</p> </li> </ul> </dd> <dt>Stopped</dt> <dd> <ul> <li> <p> <code>MaxRuntimeExceeded</code> - The job stopped because it exceeded the maximum allowed runtime.</p> </li> <li> <p> <code>Stopped</code> - The training job has stopped.</p> </li> </ul> </dd> <dt>Stopping</dt> <dd> <ul> <li> <p> <code>Stopping</code> - Stopping the training job.</p> </li> </ul> </dd> </dl> <important> <p>Valid values for <code>SecondaryStatus</code> are subject to change. </p> </important> <p>We no longer support the following secondary statuses:</p> <ul> <li> <p> <code>LaunchingMLInstances</code> </p> </li> <li> <p> <code>PreparingTrainingStack</code> </p> </li> <li> <p> <code>DownloadingTrainingImage</code> </p> </li> </ul></p>
    #[serde(rename = "SecondaryStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub secondary_status: Option<String>,
    /// <p>A history of all of the secondary statuses that the training job has transitioned through.</p>
    #[serde(rename = "SecondaryStatusTransitions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub secondary_status_transitions: Option<Vec<SecondaryStatusTransition>>,
    /// <p>Specifies a limit to how long a model training job can run. When the job reaches the time limit, Amazon SageMaker ends the training job. Use this API to cap model training costs.</p> <p>To stop a job, Amazon SageMaker sends the algorithm the <code>SIGTERM</code> signal, 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. </p>
    #[serde(rename = "StoppingCondition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopping_condition: Option<StoppingCondition>,
    /// <p>An array of key-value pairs. You can use tags to categorize your AWS resources in different ways, for example, by purpose, owner, or environment. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS Resources</a>.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    #[serde(rename = "TensorBoardOutputConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tensor_board_output_config: Option<TensorBoardOutputConfig>,
    /// <p>Indicates the time when the training job ends on training instances. You are billed for the time interval between the value of <code>TrainingStartTime</code> and this time. For successful jobs and stopped jobs, this is the time after model artifacts are uploaded. For failed jobs, this is the time when Amazon SageMaker detects a job failure.</p>
    #[serde(rename = "TrainingEndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_end_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the training job.</p>
    #[serde(rename = "TrainingJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_job_arn: Option<String>,
    /// <p>The name of the training job.</p>
    #[serde(rename = "TrainingJobName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_job_name: Option<String>,
    /// <p>The status of the training job.</p> <p>Training job statuses are:</p> <ul> <li> <p> <code>InProgress</code> - The training is in progress.</p> </li> <li> <p> <code>Completed</code> - The training job has completed.</p> </li> <li> <p> <code>Failed</code> - The training job has failed. To see the reason for the failure, see the <code>FailureReason</code> field in the response to a <code>DescribeTrainingJobResponse</code> call.</p> </li> <li> <p> <code>Stopping</code> - The training job is stopping.</p> </li> <li> <p> <code>Stopped</code> - The training job has stopped.</p> </li> </ul> <p>For more detailed information, see <code>SecondaryStatus</code>. </p>
    #[serde(rename = "TrainingJobStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_job_status: Option<String>,
    /// <p>Indicates the time when the training job starts on training instances. You are billed for the time interval between this time and the value of <code>TrainingEndTime</code>. The start time in CloudWatch Logs might be later than this time. The difference is due to the time it takes to download the training data and to the size of the training container.</p>
    #[serde(rename = "TrainingStartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_start_time: Option<f64>,
    /// <p>The training time in seconds.</p>
    #[serde(rename = "TrainingTimeInSeconds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_time_in_seconds: Option<i64>,
    /// <p>The Amazon Resource Name (ARN) of the associated hyperparameter tuning job if the training job was launched by a hyperparameter tuning job.</p>
    #[serde(rename = "TuningJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tuning_job_arn: Option<String>,
    /// <p>A <a>VpcConfig</a> object that specifies the VPC that this training job has access to. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/train-vpc.html">Protect Training Jobs by Using an Amazon Virtual Private Cloud</a>.</p>
    #[serde(rename = "VpcConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpc_config: Option<VpcConfig>,
}

/// <p>Defines the input needed to run a training job using the algorithm.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TrainingJobDefinition {
    /// <p>The hyperparameters used for the training job.</p>
    #[serde(rename = "HyperParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hyper_parameters: Option<::std::collections::HashMap<String, String>>,
    /// <p>An array of <code>Channel</code> objects, each of which specifies an input source.</p>
    #[serde(rename = "InputDataConfig")]
    pub input_data_config: Vec<Channel>,
    /// <p>the path to the S3 bucket where you want to store model artifacts. Amazon SageMaker creates subfolders for the artifacts.</p>
    #[serde(rename = "OutputDataConfig")]
    pub output_data_config: OutputDataConfig,
    /// <p>The resources, including the ML compute instances and ML storage volumes, to use for model training.</p>
    #[serde(rename = "ResourceConfig")]
    pub resource_config: ResourceConfig,
    /// <p>Specifies a limit to how long a model training job can run. When the job reaches the time limit, Amazon SageMaker ends the training job. Use this API to cap model training costs.</p> <p>To stop a job, Amazon SageMaker sends the algorithm the SIGTERM signal, which delays job termination for 120 seconds. Algorithms can use this 120-second window to save the model artifacts.</p>
    #[serde(rename = "StoppingCondition")]
    pub stopping_condition: StoppingCondition,
    /// <p>The input mode used by the algorithm for the training job. For the input modes that Amazon SageMaker algorithms support, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html">Algorithms</a>.</p> <p>If an algorithm supports the <code>File</code> input mode, Amazon SageMaker downloads the training data from S3 to the provisioned ML storage Volume, and mounts the directory to docker volume for training container. If an algorithm supports the <code>Pipe</code> input mode, Amazon SageMaker streams data directly from S3 to the container.</p>
    #[serde(rename = "TrainingInputMode")]
    pub training_input_mode: String,
}

/// <p>The numbers of training jobs launched by a hyperparameter tuning job, categorized by status.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TrainingJobStatusCounters {
    /// <p>The number of completed training jobs launched by the hyperparameter tuning job.</p>
    #[serde(rename = "Completed")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub completed: Option<i64>,
    /// <p>The number of in-progress training jobs launched by a hyperparameter tuning job.</p>
    #[serde(rename = "InProgress")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub in_progress: Option<i64>,
    /// <p>The number of training jobs that failed and can't be retried. A failed training job can't be retried if it failed because a client error occurred.</p>
    #[serde(rename = "NonRetryableError")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub non_retryable_error: Option<i64>,
    /// <p>The number of training jobs that failed, but can be retried. A failed training job can be retried only if it failed because an internal service error occurred.</p>
    #[serde(rename = "RetryableError")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retryable_error: Option<i64>,
    /// <p>The number of training jobs launched by a hyperparameter tuning job that were manually stopped.</p>
    #[serde(rename = "Stopped")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stopped: Option<i64>,
}

/// <p>Metadata for a training job step.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TrainingJobStepMetadata {
    /// <p>The Amazon Resource Name (ARN) of the training job that was run by this step execution.</p>
    #[serde(rename = "Arn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub arn: Option<String>,
}

/// <p>Provides summary information about a training job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TrainingJobSummary {
    /// <p>A timestamp that shows when the training job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p> Timestamp when the training job was last modified. </p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>A timestamp that shows when the training job ended. This field is set only if the training job has one of the terminal statuses (<code>Completed</code>, <code>Failed</code>, or <code>Stopped</code>). </p>
    #[serde(rename = "TrainingEndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_end_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the training job.</p>
    #[serde(rename = "TrainingJobArn")]
    pub training_job_arn: String,
    /// <p>The name of the training job that you want a summary for.</p>
    #[serde(rename = "TrainingJobName")]
    pub training_job_name: String,
    /// <p>The status of the training job.</p>
    #[serde(rename = "TrainingJobStatus")]
    pub training_job_status: String,
}

/// <p>Defines how the algorithm is used for a training job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TrainingSpecification {
    /// <p>A list of <code>MetricDefinition</code> objects, which are used for parsing metrics generated by the algorithm.</p>
    #[serde(rename = "MetricDefinitions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metric_definitions: Option<Vec<MetricDefinition>>,
    /// <p>A list of the <code>HyperParameterSpecification</code> objects, that define the supported hyperparameters. This is required if the algorithm supports automatic model tuning.&gt;</p>
    #[serde(rename = "SupportedHyperParameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub supported_hyper_parameters: Option<Vec<HyperParameterSpecification>>,
    /// <p>A list of the instance types that this algorithm can use for training.</p>
    #[serde(rename = "SupportedTrainingInstanceTypes")]
    pub supported_training_instance_types: Vec<String>,
    /// <p>A list of the metrics that the algorithm emits that can be used as the objective metric in a hyperparameter tuning job.</p>
    #[serde(rename = "SupportedTuningJobObjectiveMetrics")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub supported_tuning_job_objective_metrics: Option<Vec<HyperParameterTuningJobObjective>>,
    /// <p>Indicates whether the algorithm supports distributed training. If set to false, buyers can't request more than one instance during training.</p>
    #[serde(rename = "SupportsDistributedTraining")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub supports_distributed_training: Option<bool>,
    /// <p>A list of <code>ChannelSpecification</code> objects, which specify the input sources to be used by the algorithm.</p>
    #[serde(rename = "TrainingChannels")]
    pub training_channels: Vec<ChannelSpecification>,
    /// <p>The Amazon ECR registry path of the Docker image that contains the training algorithm.</p>
    #[serde(rename = "TrainingImage")]
    pub training_image: String,
    /// <p>An MD5 hash of the training algorithm that identifies the Docker image used for training.</p>
    #[serde(rename = "TrainingImageDigest")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_image_digest: Option<String>,
}

/// <p>Describes the location of the channel data.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TransformDataSource {
    /// <p>The S3 location of the data source that is associated with a channel.</p>
    #[serde(rename = "S3DataSource")]
    pub s3_data_source: TransformS3DataSource,
}

/// <p>Describes the input source of a transform job and the way the transform job consumes it.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TransformInput {
    /// <p>If your transform data is compressed, specify the compression type. Amazon SageMaker automatically decompresses the data for the transform job accordingly. The default value is <code>None</code>.</p>
    #[serde(rename = "CompressionType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub compression_type: Option<String>,
    /// <p>The multipurpose internet mail extension (MIME) type of the data. Amazon SageMaker uses the MIME type with each http call to transfer data to the transform job.</p>
    #[serde(rename = "ContentType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content_type: Option<String>,
    /// <p>Describes the location of the channel data, which is, the S3 location of the input data that the model can consume.</p>
    #[serde(rename = "DataSource")]
    pub data_source: TransformDataSource,
    /// <p><p>The method to use to split the transform job&#39;s data files into smaller batches. Splitting is necessary when the total size of each object is too large to fit in a single request. You can also use data splitting to improve performance by processing multiple concurrent mini-batches. The default value for <code>SplitType</code> is <code>None</code>, which indicates that input data files are not split, and request payloads contain the entire contents of an input object. Set the value of this parameter to <code>Line</code> to split records on a newline character boundary. <code>SplitType</code> also supports a number of record-oriented binary data formats. Currently, the supported record formats are:</p> <ul> <li> <p>RecordIO</p> </li> <li> <p>TFRecord</p> </li> </ul> <p>When splitting is enabled, the size of a mini-batch depends on the values of the <code>BatchStrategy</code> and <code>MaxPayloadInMB</code> parameters. When the value of <code>BatchStrategy</code> is <code>MultiRecord</code>, Amazon SageMaker sends the maximum number of records in each request, up to the <code>MaxPayloadInMB</code> limit. If the value of <code>BatchStrategy</code> is <code>SingleRecord</code>, Amazon SageMaker sends individual records in each request.</p> <note> <p>Some data formats represent a record as a binary payload wrapped with extra padding bytes. When splitting is applied to a binary data format, padding is removed if the value of <code>BatchStrategy</code> is set to <code>SingleRecord</code>. Padding is not removed if the value of <code>BatchStrategy</code> is set to <code>MultiRecord</code>.</p> <p>For more information about <code>RecordIO</code>, see <a href="https://mxnet.apache.org/api/faq/recordio">Create a Dataset Using RecordIO</a> in the MXNet documentation. For more information about <code>TFRecord</code>, see <a href="https://www.tensorflow.org/guide/datasets#consuming_tfrecord_data">Consuming TFRecord data</a> in the TensorFlow documentation.</p> </note></p>
    #[serde(rename = "SplitType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub split_type: Option<String>,
}

/// <p>A batch transform job. For information about SageMaker batch transform, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform.html">Use Batch Transform</a>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TransformJob {
    /// <p>The Amazon Resource Name (ARN) of the AutoML job that created the transform job.</p>
    #[serde(rename = "AutoMLJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_ml_job_arn: Option<String>,
    /// <p>Specifies the number of records to include in a mini-batch for an HTTP inference request. A record is a single unit of input data that inference can be made on. For example, a single line in a CSV file is a record.</p>
    #[serde(rename = "BatchStrategy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub batch_strategy: Option<String>,
    /// <p>A timestamp that shows when the transform Job was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    #[serde(rename = "DataProcessing")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data_processing: Option<DataProcessing>,
    /// <p>The environment variables to set in the Docker container. We support up to 16 key and values entries in the map.</p>
    #[serde(rename = "Environment")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub environment: Option<::std::collections::HashMap<String, String>>,
    #[serde(rename = "ExperimentConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_config: Option<ExperimentConfig>,
    /// <p>If the transform job failed, the reason it failed.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the labeling job that created the transform job.</p>
    #[serde(rename = "LabelingJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub labeling_job_arn: Option<String>,
    /// <p>The maximum number of parallel requests that can be sent to each instance in a transform job. If <code>MaxConcurrentTransforms</code> is set to 0 or left unset, SageMaker checks the optional execution-parameters to determine the settings for your chosen algorithm. If the execution-parameters endpoint is not enabled, the default value is 1. For built-in algorithms, you don't need to set a value for <code>MaxConcurrentTransforms</code>.</p>
    #[serde(rename = "MaxConcurrentTransforms")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_concurrent_transforms: Option<i64>,
    /// <p>The maximum allowed size of the payload, in MB. A payload is the data portion of a record (without metadata). The value in <code>MaxPayloadInMB</code> must be greater than, or equal to, the size of a single record. To estimate the size of a record in MB, divide the size of your dataset by the number of records. To ensure that the records fit within the maximum payload size, we recommend using a slightly larger value. The default value is 6 MB. For cases where the payload might be arbitrarily large and is transmitted using HTTP chunked encoding, set the value to 0. This feature works only in supported algorithms. Currently, SageMaker built-in algorithms do not support HTTP chunked encoding.</p>
    #[serde(rename = "MaxPayloadInMB")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_payload_in_mb: Option<i64>,
    #[serde(rename = "ModelClientConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_client_config: Option<ModelClientConfig>,
    /// <p>The name of the model associated with the transform job.</p>
    #[serde(rename = "ModelName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_name: Option<String>,
    /// <p>A list of tags associated with the transform job.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>Indicates when the transform job has been completed, or has stopped or failed. You are billed for the time interval between this time and the value of <code>TransformStartTime</code>.</p>
    #[serde(rename = "TransformEndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transform_end_time: Option<f64>,
    #[serde(rename = "TransformInput")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transform_input: Option<TransformInput>,
    /// <p>The Amazon Resource Name (ARN) of the transform job.</p>
    #[serde(rename = "TransformJobArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transform_job_arn: Option<String>,
    /// <p>The name of the transform job.</p>
    #[serde(rename = "TransformJobName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transform_job_name: Option<String>,
    /// <p><p>The status of the transform job.</p> <p>Transform job statuses are:</p> <ul> <li> <p> <code>InProgress</code> - The job is in progress.</p> </li> <li> <p> <code>Completed</code> - The job has completed.</p> </li> <li> <p> <code>Failed</code> - The transform job has failed. To see the reason for the failure, see the <code>FailureReason</code> field in the response to a <code>DescribeTransformJob</code> call.</p> </li> <li> <p> <code>Stopping</code> - The transform job is stopping.</p> </li> <li> <p> <code>Stopped</code> - The transform job has stopped.</p> </li> </ul></p>
    #[serde(rename = "TransformJobStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transform_job_status: Option<String>,
    #[serde(rename = "TransformOutput")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transform_output: Option<TransformOutput>,
    #[serde(rename = "TransformResources")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transform_resources: Option<TransformResources>,
    /// <p>Indicates when the transform job starts on ML instances. You are billed for the time interval between this time and the value of <code>TransformEndTime</code>.</p>
    #[serde(rename = "TransformStartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transform_start_time: Option<f64>,
}

/// <p>Defines the input needed to run a transform job using the inference specification specified in the algorithm.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TransformJobDefinition {
    /// <p>A string that determines the number of records included in a single mini-batch.</p> <p> <code>SingleRecord</code> means only one record is used per mini-batch. <code>MultiRecord</code> means a mini-batch is set to contain as many records that can fit within the <code>MaxPayloadInMB</code> limit.</p>
    #[serde(rename = "BatchStrategy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub batch_strategy: Option<String>,
    /// <p>The environment variables to set in the Docker container. We support up to 16 key and values entries in the map.</p>
    #[serde(rename = "Environment")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub environment: Option<::std::collections::HashMap<String, String>>,
    /// <p>The maximum number of parallel requests that can be sent to each instance in a transform job. The default value is 1.</p>
    #[serde(rename = "MaxConcurrentTransforms")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_concurrent_transforms: Option<i64>,
    /// <p>The maximum payload size allowed, in MB. A payload is the data portion of a record (without metadata).</p>
    #[serde(rename = "MaxPayloadInMB")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_payload_in_mb: Option<i64>,
    /// <p>A description of the input source and the way the transform job consumes it.</p>
    #[serde(rename = "TransformInput")]
    pub transform_input: TransformInput,
    /// <p>Identifies the Amazon S3 location where you want Amazon SageMaker to save the results from the transform job.</p>
    #[serde(rename = "TransformOutput")]
    pub transform_output: TransformOutput,
    /// <p>Identifies the ML compute instances for the transform job.</p>
    #[serde(rename = "TransformResources")]
    pub transform_resources: TransformResources,
}

/// <p>Metadata for a transform job step.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TransformJobStepMetadata {
    /// <p>The Amazon Resource Name (ARN) of the transform job that was run by this step execution.</p>
    #[serde(rename = "Arn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub arn: Option<String>,
}

/// <p>Provides a summary of a transform job. Multiple <code>TransformJobSummary</code> objects are returned as a list after in response to a <a>ListTransformJobs</a> call.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TransformJobSummary {
    /// <p>A timestamp that shows when the transform Job was created.</p>
    #[serde(rename = "CreationTime")]
    pub creation_time: f64,
    /// <p>If the transform job failed, the reason it failed.</p>
    #[serde(rename = "FailureReason")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    /// <p>Indicates when the transform job was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>Indicates when the transform job ends on compute instances. For successful jobs and stopped jobs, this is the exact time recorded after the results are uploaded. For failed jobs, this is when Amazon SageMaker detected that the job failed.</p>
    #[serde(rename = "TransformEndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transform_end_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the transform job.</p>
    #[serde(rename = "TransformJobArn")]
    pub transform_job_arn: String,
    /// <p>The name of the transform job.</p>
    #[serde(rename = "TransformJobName")]
    pub transform_job_name: String,
    /// <p>The status of the transform job.</p>
    #[serde(rename = "TransformJobStatus")]
    pub transform_job_status: String,
}

/// <p>Describes the results of a transform job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TransformOutput {
    /// <p>The MIME type used to specify the output data. Amazon SageMaker uses the MIME type with each http call to transfer data from the transform job.</p>
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accept: Option<String>,
    /// <p>Defines how to assemble the results of the transform job as a single S3 object. Choose a format that is most convenient to you. To concatenate the results in binary format, specify <code>None</code>. To add a newline character at the end of every transformed record, specify <code>Line</code>.</p>
    #[serde(rename = "AssembleWith")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub assemble_with: Option<String>,
    /// <p>The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt the model artifacts at rest using Amazon S3 server-side encryption. The <code>KmsKeyId</code> can be any of the following formats: </p> <ul> <li> <p>Key ID: <code>1234abcd-12ab-34cd-56ef-1234567890ab</code> </p> </li> <li> <p>Key ARN: <code>arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab</code> </p> </li> <li> <p>Alias name: <code>alias/ExampleAlias</code> </p> </li> <li> <p>Alias name ARN: <code>arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias</code> </p> </li> </ul> <p>If you don't provide a KMS key ID, Amazon SageMaker uses the default KMS key for Amazon S3 for your role's account. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html">KMS-Managed Encryption Keys</a> in the <i>Amazon Simple Storage Service Developer Guide.</i> </p> <p>The KMS key policy must grant permission to the IAM role that you specify in your <a>CreateModel</a> request. For more information, see <a href="http://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html">Using Key Policies in AWS KMS</a> in the <i>AWS Key Management Service Developer Guide</i>.</p>
    #[serde(rename = "KmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kms_key_id: Option<String>,
    /// <p>The Amazon S3 path where you want Amazon SageMaker to store the results of the transform job. For example, <code>s3://bucket-name/key-name-prefix</code>.</p> <p>For every S3 object used as input for the transform job, batch transform stores the transformed data with an .<code>out</code> suffix in a corresponding subfolder in the location in the output prefix. For example, for the input data stored at <code>s3://bucket-name/input-name-prefix/dataset01/data.csv</code>, batch transform stores the transformed data at <code>s3://bucket-name/output-name-prefix/input-name-prefix/data.csv.out</code>. Batch transform doesn't upload partially processed objects. For an input S3 object that contains multiple records, it creates an .<code>out</code> file only if the transform job succeeds on the entire file. When the input contains multiple S3 objects, the batch transform job processes the listed S3 objects and uploads only the output for successfully processed objects. If any object fails in the transform job batch transform marks the job as failed to prompt investigation.</p>
    #[serde(rename = "S3OutputPath")]
    pub s3_output_path: String,
}

/// <p>Describes the resources, including ML instance types and ML instance count, to use for transform job.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TransformResources {
    /// <p>The number of ML compute instances to use in the transform job. For distributed transform jobs, specify a value greater than 1. The default value is <code>1</code>.</p>
    #[serde(rename = "InstanceCount")]
    pub instance_count: i64,
    /// <p>The ML compute instance type for the transform job. If you are using built-in algorithms to transform moderately sized datasets, we recommend using ml.m4.xlarge or <code>ml.m5.large</code> instance types.</p>
    #[serde(rename = "InstanceType")]
    pub instance_type: String,
    /// <p><p>The AWS Key Management Service (AWS KMS) key that Amazon SageMaker uses to encrypt model data on the storage volume attached to the ML compute instance(s) that run the batch transform job. The <code>VolumeKmsKeyId</code> can be any of the following formats:</p> <ul> <li> <p>Key ID: <code>1234abcd-12ab-34cd-56ef-1234567890ab</code> </p> </li> <li> <p>Key ARN: <code>arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab</code> </p> </li> <li> <p>Alias name: <code>alias/ExampleAlias</code> </p> </li> <li> <p>Alias name ARN: <code>arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias</code> </p> </li> </ul></p>
    #[serde(rename = "VolumeKmsKeyId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume_kms_key_id: Option<String>,
}

/// <p>Describes the S3 data source.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TransformS3DataSource {
    /// <p>If you choose <code>S3Prefix</code>, <code>S3Uri</code> identifies a key name prefix. Amazon SageMaker uses all objects with the specified key name prefix for batch transform. </p> <p>If you choose <code>ManifestFile</code>, <code>S3Uri</code> identifies an object that is a manifest file containing a list of object keys that you want Amazon SageMaker to use for batch transform. </p> <p>The following values are compatible: <code>ManifestFile</code>, <code>S3Prefix</code> </p> <p>The following value is not compatible: <code>AugmentedManifestFile</code> </p>
    #[serde(rename = "S3DataType")]
    pub s3_data_type: String,
    /// <p><p>Depending on the value specified for the <code>S3DataType</code>, identifies either a key name prefix or a manifest. For example:</p> <ul> <li> <p> A key name prefix might look like this: <code>s3://bucketname/exampleprefix</code>. </p> </li> <li> <p> A manifest might look like this: <code>s3://bucketname/example.manifest</code> </p> <p> The manifest is an S3 object which is a JSON file with the following format: </p> <p> <code>[ {&quot;prefix&quot;: &quot;s3://customer<em>bucket/some/prefix/&quot;},</code> </p> <p> <code>&quot;relative/path/to/custdata-1&quot;,</code> </p> <p> <code>&quot;relative/path/custdata-2&quot;,</code> </p> <p> <code>...</code> </p> <p> <code>&quot;relative/path/custdata-N&quot;</code> </p> <p> <code>]</code> </p> <p> The preceding JSON matches the following <code>S3Uris</code>: </p> <p> <code>s3://customer</em>bucket/some/prefix/relative/path/to/custdata-1</code> </p> <p> <code>s3://customer<em>bucket/some/prefix/relative/path/custdata-2</code> </p> <p> <code>...</code> </p> <p> <code>s3://customer</em>bucket/some/prefix/relative/path/custdata-N</code> </p> <p> The complete set of <code>S3Uris</code> in this manifest constitutes the input data for the channel for this datasource. The object that each <code>S3Uris</code> points to must be readable by the IAM role that Amazon SageMaker uses to perform tasks on your behalf.</p> </li> </ul></p>
    #[serde(rename = "S3Uri")]
    pub s3_uri: String,
}

/// <p>The properties of a trial as returned by the <a>Search</a> API.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Trial {
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>When the trial was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The name of the trial as displayed. If <code>DisplayName</code> isn't specified, <code>TrialName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>The name of the experiment the trial is part of.</p>
    #[serde(rename = "ExperimentName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_name: Option<String>,
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>Who last modified the trial.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    #[serde(rename = "MetadataProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_properties: Option<MetadataProperties>,
    #[serde(rename = "Source")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<TrialSource>,
    /// <p>The list of tags that are associated with the trial. You can use <a>Search</a> API to search on the tags.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>The Amazon Resource Name (ARN) of the trial.</p>
    #[serde(rename = "TrialArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_arn: Option<String>,
    /// <p>A list of the components associated with the trial. For each component, a summary of the component's properties is included.</p>
    #[serde(rename = "TrialComponentSummaries")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_summaries: Option<Vec<TrialComponentSimpleSummary>>,
    /// <p>The name of the trial.</p>
    #[serde(rename = "TrialName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_name: Option<String>,
}

/// <p>The properties of a trial component as returned by the <a>Search</a> API.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TrialComponent {
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>When the component was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The name of the component as displayed. If <code>DisplayName</code> isn't specified, <code>TrialComponentName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>When the component ended.</p>
    #[serde(rename = "EndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub end_time: Option<f64>,
    /// <p>The input artifacts of the component.</p>
    #[serde(rename = "InputArtifacts")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_artifacts: Option<::std::collections::HashMap<String, TrialComponentArtifact>>,
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>When the component was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    #[serde(rename = "MetadataProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_properties: Option<MetadataProperties>,
    /// <p>The metrics for the component.</p>
    #[serde(rename = "Metrics")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metrics: Option<Vec<TrialComponentMetricSummary>>,
    /// <p>The output artifacts of the component.</p>
    #[serde(rename = "OutputArtifacts")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_artifacts: Option<::std::collections::HashMap<String, TrialComponentArtifact>>,
    /// <p>The hyperparameters of the component.</p>
    #[serde(rename = "Parameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parameters: Option<::std::collections::HashMap<String, TrialComponentParameterValue>>,
    /// <p>An array of the parents of the component. A parent is a trial the component is associated with and the experiment the trial is part of. A component might not have any parents.</p>
    #[serde(rename = "Parents")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parents: Option<Vec<Parent>>,
    /// <p>The Amazon Resource Name (ARN) and job type of the source of the component.</p>
    #[serde(rename = "Source")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<TrialComponentSource>,
    /// <p>Details of the source of the component.</p>
    #[serde(rename = "SourceDetail")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_detail: Option<TrialComponentSourceDetail>,
    /// <p>When the component started.</p>
    #[serde(rename = "StartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start_time: Option<f64>,
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<TrialComponentStatus>,
    /// <p>The list of tags that are associated with the component. You can use <a>Search</a> API to search on the tags.</p>
    #[serde(rename = "Tags")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<Tag>>,
    /// <p>The Amazon Resource Name (ARN) of the trial component.</p>
    #[serde(rename = "TrialComponentArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_arn: Option<String>,
    /// <p>The name of the trial component.</p>
    #[serde(rename = "TrialComponentName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_name: Option<String>,
}

/// <p>Represents an input or output artifact of a trial component. You specify <code>TrialComponentArtifact</code> as part of the <code>InputArtifacts</code> and <code>OutputArtifacts</code> parameters in the <a>CreateTrialComponent</a> request.</p> <p>Examples of input artifacts are datasets, algorithms, hyperparameters, source code, and instance types. Examples of output artifacts are metrics, snapshots, logs, and images.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TrialComponentArtifact {
    /// <p>The media type of the artifact, which indicates the type of data in the artifact file. The media type consists of a <i>type</i> and a <i>subtype</i> concatenated with a slash (/) character, for example, text/csv, image/jpeg, and s3/uri. The type specifies the category of the media. The subtype specifies the kind of data.</p>
    #[serde(rename = "MediaType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub media_type: Option<String>,
    /// <p>The location of the artifact.</p>
    #[serde(rename = "Value")]
    pub value: String,
}

/// <p>A summary of the metrics of a trial component.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TrialComponentMetricSummary {
    /// <p>The average value of the metric.</p>
    #[serde(rename = "Avg")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub avg: Option<f64>,
    /// <p>The number of samples used to generate the metric.</p>
    #[serde(rename = "Count")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub count: Option<i64>,
    /// <p>The most recent value of the metric.</p>
    #[serde(rename = "Last")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last: Option<f64>,
    /// <p>The maximum value of the metric.</p>
    #[serde(rename = "Max")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max: Option<f64>,
    /// <p>The name of the metric.</p>
    #[serde(rename = "MetricName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metric_name: Option<String>,
    /// <p>The minimum value of the metric.</p>
    #[serde(rename = "Min")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub min: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the source.</p>
    #[serde(rename = "SourceArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_arn: Option<String>,
    /// <p>The standard deviation of the metric.</p>
    #[serde(rename = "StdDev")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub std_dev: Option<f64>,
    /// <p>When the metric was last updated.</p>
    #[serde(rename = "TimeStamp")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub time_stamp: Option<f64>,
}

/// <p>The value of a hyperparameter. Only one of <code>NumberValue</code> or <code>StringValue</code> can be specified.</p> <p>This object is specified in the <a>CreateTrialComponent</a> request.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TrialComponentParameterValue {
    /// <p>The numeric value of a numeric hyperparameter. If you specify a value for this parameter, you can't specify the <code>StringValue</code> parameter.</p>
    #[serde(rename = "NumberValue")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub number_value: Option<f64>,
    /// <p>The string value of a categorical hyperparameter. If you specify a value for this parameter, you can't specify the <code>NumberValue</code> parameter.</p>
    #[serde(rename = "StringValue")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub string_value: Option<String>,
}

/// <p>A short summary of a trial component.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TrialComponentSimpleSummary {
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>When the component was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the trial component.</p>
    #[serde(rename = "TrialComponentArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_arn: Option<String>,
    /// <p>The name of the trial component.</p>
    #[serde(rename = "TrialComponentName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_name: Option<String>,
    #[serde(rename = "TrialComponentSource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_source: Option<TrialComponentSource>,
}

/// <p>The Amazon Resource Name (ARN) and job type of the source of a trial component.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TrialComponentSource {
    /// <p>The source ARN.</p>
    #[serde(rename = "SourceArn")]
    pub source_arn: String,
    /// <p>The source job type.</p>
    #[serde(rename = "SourceType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_type: Option<String>,
}

/// <p>Detailed information about the source of a trial component. Either <code>ProcessingJob</code> or <code>TrainingJob</code> is returned.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TrialComponentSourceDetail {
    /// <p>Information about a processing job that's the source of a trial component.</p>
    #[serde(rename = "ProcessingJob")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub processing_job: Option<ProcessingJob>,
    /// <p>The Amazon Resource Name (ARN) of the source.</p>
    #[serde(rename = "SourceArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_arn: Option<String>,
    /// <p>Information about a training job that's the source of a trial component.</p>
    #[serde(rename = "TrainingJob")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub training_job: Option<TrainingJob>,
    /// <p>Information about a transform job that's the source of a trial component.</p>
    #[serde(rename = "TransformJob")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transform_job: Option<TransformJob>,
}

/// <p>The status of the trial component.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TrialComponentStatus {
    /// <p>If the component failed, a message describing why.</p>
    #[serde(rename = "Message")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    /// <p>The status of the trial component.</p>
    #[serde(rename = "PrimaryStatus")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub primary_status: Option<String>,
}

/// <p>A summary of the properties of a trial component. To get all the properties, call the <a>DescribeTrialComponent</a> API and provide the <code>TrialComponentName</code>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TrialComponentSummary {
    /// <p>Who created the component.</p>
    #[serde(rename = "CreatedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by: Option<UserContext>,
    /// <p>When the component was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The name of the component as displayed. If <code>DisplayName</code> isn't specified, <code>TrialComponentName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>When the component ended.</p>
    #[serde(rename = "EndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub end_time: Option<f64>,
    /// <p>Who last modified the component.</p>
    #[serde(rename = "LastModifiedBy")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<UserContext>,
    /// <p>When the component was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>When the component started.</p>
    #[serde(rename = "StartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start_time: Option<f64>,
    /// <p><p>The status of the component. States include:</p> <ul> <li> <p>InProgress</p> </li> <li> <p>Completed</p> </li> <li> <p>Failed</p> </li> </ul></p>
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<TrialComponentStatus>,
    /// <p>The ARN of the trial component.</p>
    #[serde(rename = "TrialComponentArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_arn: Option<String>,
    /// <p>The name of the trial component.</p>
    #[serde(rename = "TrialComponentName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_name: Option<String>,
    #[serde(rename = "TrialComponentSource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_source: Option<TrialComponentSource>,
}

/// <p>The source of the trial.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TrialSource {
    /// <p>The Amazon Resource Name (ARN) of the source.</p>
    #[serde(rename = "SourceArn")]
    pub source_arn: String,
    /// <p>The source job type.</p>
    #[serde(rename = "SourceType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_type: Option<String>,
}

/// <p>A summary of the properties of a trial. To get the complete set of properties, call the <a>DescribeTrial</a> API and provide the <code>TrialName</code>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TrialSummary {
    /// <p>When the trial was created.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The name of the trial as displayed. If <code>DisplayName</code> isn't specified, <code>TrialName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>When the trial was last modified.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The Amazon Resource Name (ARN) of the trial.</p>
    #[serde(rename = "TrialArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_arn: Option<String>,
    /// <p>The name of the trial.</p>
    #[serde(rename = "TrialName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_name: Option<String>,
    #[serde(rename = "TrialSource")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_source: Option<TrialSource>,
}

/// <p>The job completion criteria.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TuningJobCompletionCriteria {
    /// <p>The value of the objective metric.</p>
    #[serde(rename = "TargetObjectiveMetricValue")]
    pub target_objective_metric_value: f32,
}

/// <p>Represents an amount of money in United States dollars/</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct USD {
    /// <p>The fractional portion, in cents, of the amount. </p>
    #[serde(rename = "Cents")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cents: Option<i64>,
    /// <p>The whole number of dollars in the amount.</p>
    #[serde(rename = "Dollars")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dollars: Option<i64>,
    /// <p>Fractions of a cent, in tenths.</p>
    #[serde(rename = "TenthFractionsOfACent")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tenth_fractions_of_a_cent: Option<i64>,
}

/// <p>Provided configuration information for the worker UI for a labeling job. </p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct UiConfig {
    /// <p><p>The ARN of the worker task template used to render the worker UI and tools for labeling job tasks.</p> <p>Use this parameter when you are creating a labeling job for 3D point cloud and video fram labeling jobs. Use your labeling job task type to select one of the following ARN&#39;s and use it with this parameter when you create a labeling job. Replace <code>aws-region</code> with the AWS region you are creating your labeling job in.</p> <p> <b>3D Point Cloud HumanTaskUiArns</b> </p> <p>Use this <code>HumanTaskUiArn</code> for 3D point cloud object detection and 3D point cloud object detection adjustment labeling jobs. </p> <ul> <li> <p> <code>arn:aws:sagemaker:aws-region:394669845002:human-task-ui/PointCloudObjectDetection</code> </p> </li> </ul> <p> Use this <code>HumanTaskUiArn</code> for 3D point cloud object tracking and 3D point cloud object tracking adjustment labeling jobs. </p> <ul> <li> <p> <code>arn:aws:sagemaker:aws-region:394669845002:human-task-ui/PointCloudObjectTracking</code> </p> </li> </ul> <p> Use this <code>HumanTaskUiArn</code> for 3D point cloud semantic segmentation and 3D point cloud semantic segmentation adjustment labeling jobs.</p> <ul> <li> <p> <code>arn:aws:sagemaker:aws-region:394669845002:human-task-ui/PointCloudSemanticSegmentation</code> </p> </li> </ul> <p> <b>Video Frame HumanTaskUiArns</b> </p> <p>Use this <code>HumanTaskUiArn</code> for video frame object detection and video frame object detection adjustment labeling jobs. </p> <ul> <li> <p> <code>arn:aws:sagemaker:region:394669845002:human-task-ui/VideoObjectDetection</code> </p> </li> </ul> <p> Use this <code>HumanTaskUiArn</code> for video frame object tracking and video frame object tracking adjustment labeling jobs. </p> <ul> <li> <p> <code>arn:aws:sagemaker:aws-region:394669845002:human-task-ui/VideoObjectTracking</code> </p> </li> </ul></p>
    #[serde(rename = "HumanTaskUiArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub human_task_ui_arn: Option<String>,
    /// <p>The Amazon S3 bucket location of the UI template, or worker task template. This is the template used to render the worker UI and tools for labeling job tasks. For more information about the contents of a UI template, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-custom-templates-step2.html"> Creating Your Custom Labeling Task Template</a>.</p>
    #[serde(rename = "UiTemplateS3Uri")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ui_template_s3_uri: Option<String>,
}

/// <p>The Liquid template for the worker user interface.</p>
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UiTemplate {
    /// <p>The content of the Liquid template for the worker user interface.</p>
    #[serde(rename = "Content")]
    pub content: String,
}

/// <p>Container for user interface template information.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UiTemplateInfo {
    /// <p>The SHA-256 digest of the contents of the template.</p>
    #[serde(rename = "ContentSha256")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content_sha_256: Option<String>,
    /// <p>The URL for the user interface template.</p>
    #[serde(rename = "Url")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateActionRequest {
    /// <p>The name of the action to update.</p>
    #[serde(rename = "ActionName")]
    pub action_name: String,
    /// <p>The new description for the action.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The new list of properties. Overwrites the current property list.</p>
    #[serde(rename = "Properties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub properties: Option<::std::collections::HashMap<String, String>>,
    /// <p>A list of properties to remove.</p>
    #[serde(rename = "PropertiesToRemove")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub properties_to_remove: Option<Vec<String>>,
    /// <p>The new status for the action.</p>
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateActionResponse {
    /// <p>The Amazon Resource Name (ARN) of the action.</p>
    #[serde(rename = "ActionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub action_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateAppImageConfigRequest {
    /// <p>The name of the AppImageConfig to update.</p>
    #[serde(rename = "AppImageConfigName")]
    pub app_image_config_name: String,
    /// <p>The new KernelGateway app to run on the image.</p>
    #[serde(rename = "KernelGatewayImageConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kernel_gateway_image_config: Option<KernelGatewayImageConfig>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateAppImageConfigResponse {
    /// <p>The Amazon Resource Name (ARN) for the AppImageConfig.</p>
    #[serde(rename = "AppImageConfigArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_image_config_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateArtifactRequest {
    /// <p>The Amazon Resource Name (ARN) of the artifact to update.</p>
    #[serde(rename = "ArtifactArn")]
    pub artifact_arn: String,
    /// <p>The new name for the artifact.</p>
    #[serde(rename = "ArtifactName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artifact_name: Option<String>,
    /// <p>The new list of properties. Overwrites the current property list.</p>
    #[serde(rename = "Properties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub properties: Option<::std::collections::HashMap<String, String>>,
    /// <p>A list of properties to remove.</p>
    #[serde(rename = "PropertiesToRemove")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub properties_to_remove: Option<Vec<String>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateArtifactResponse {
    /// <p>The Amazon Resource Name (ARN) of the artifact.</p>
    #[serde(rename = "ArtifactArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artifact_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateCodeRepositoryInput {
    /// <p>The name of the Git repository to update.</p>
    #[serde(rename = "CodeRepositoryName")]
    pub code_repository_name: String,
    /// <p>The configuration of the git repository, including the URL and the Amazon Resource Name (ARN) of the AWS Secrets Manager secret that contains the credentials used to access the repository. The secret must have a staging label of <code>AWSCURRENT</code> and must be in the following format:</p> <p> <code>{"username": <i>UserName</i>, "password": <i>Password</i>}</code> </p>
    #[serde(rename = "GitConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub git_config: Option<GitConfigForUpdate>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateCodeRepositoryOutput {
    /// <p>The ARN of the Git repository.</p>
    #[serde(rename = "CodeRepositoryArn")]
    pub code_repository_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateContextRequest {
    /// <p>The name of the context to update.</p>
    #[serde(rename = "ContextName")]
    pub context_name: String,
    /// <p>The new description for the context.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The new list of properties. Overwrites the current property list.</p>
    #[serde(rename = "Properties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub properties: Option<::std::collections::HashMap<String, String>>,
    /// <p>A list of properties to remove.</p>
    #[serde(rename = "PropertiesToRemove")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub properties_to_remove: Option<Vec<String>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateContextResponse {
    /// <p>The Amazon Resource Name (ARN) of the context.</p>
    #[serde(rename = "ContextArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDeviceFleetRequest {
    /// <p>Description of the fleet.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The name of the fleet.</p>
    #[serde(rename = "DeviceFleetName")]
    pub device_fleet_name: String,
    /// <p>Output configuration for storing sample data collected by the fleet.</p>
    #[serde(rename = "OutputConfig")]
    pub output_config: EdgeOutputConfig,
    /// <p>The Amazon Resource Name (ARN) of the device.</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDevicesRequest {
    /// <p>The name of the fleet the devices belong to.</p>
    #[serde(rename = "DeviceFleetName")]
    pub device_fleet_name: String,
    /// <p>List of devices to register with Edge Manager agent.</p>
    #[serde(rename = "Devices")]
    pub devices: Vec<Device>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDomainRequest {
    /// <p>A collection of settings.</p>
    #[serde(rename = "DefaultUserSettings")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_user_settings: Option<UserSettings>,
    /// <p>The ID of the domain to be updated.</p>
    #[serde(rename = "DomainId")]
    pub domain_id: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDomainResponse {
    /// <p>The Amazon Resource Name (ARN) of the domain.</p>
    #[serde(rename = "DomainArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateEndpointInput {
    /// <p>The deployment configuration for the endpoint to be updated.</p>
    #[serde(rename = "DeploymentConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deployment_config: Option<DeploymentConfig>,
    /// <p>The name of the new endpoint configuration.</p>
    #[serde(rename = "EndpointConfigName")]
    pub endpoint_config_name: String,
    /// <p>The name of the endpoint whose configuration you want to update.</p>
    #[serde(rename = "EndpointName")]
    pub endpoint_name: String,
    /// <p>When you are updating endpoint resources with <a>UpdateEndpointInput$RetainAllVariantProperties</a>, whose value is set to <code>true</code>, <code>ExcludeRetainedVariantProperties</code> specifies the list of type <a>VariantProperty</a> to override with the values provided by <code>EndpointConfig</code>. If you don't specify a value for <code>ExcludeAllVariantProperties</code>, no variant properties are overridden. </p>
    #[serde(rename = "ExcludeRetainedVariantProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub exclude_retained_variant_properties: Option<Vec<VariantProperty>>,
    /// <p>When updating endpoint resources, enables or disables the retention of <a href="https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_VariantProperty.html">variant properties</a>, such as the instance count or the variant weight. To retain the variant properties of an endpoint when updating it, set <code>RetainAllVariantProperties</code> to <code>true</code>. To use the variant properties specified in a new <code>EndpointConfig</code> call when updating an endpoint, set <code>RetainAllVariantProperties</code> to <code>false</code>. The default is <code>false</code>.</p>
    #[serde(rename = "RetainAllVariantProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retain_all_variant_properties: Option<bool>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateEndpointOutput {
    /// <p>The Amazon Resource Name (ARN) of the endpoint.</p>
    #[serde(rename = "EndpointArn")]
    pub endpoint_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateEndpointWeightsAndCapacitiesInput {
    /// <p>An object that provides new capacity and weight values for a variant.</p>
    #[serde(rename = "DesiredWeightsAndCapacities")]
    pub desired_weights_and_capacities: Vec<DesiredWeightAndCapacity>,
    /// <p>The name of an existing Amazon SageMaker endpoint.</p>
    #[serde(rename = "EndpointName")]
    pub endpoint_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateEndpointWeightsAndCapacitiesOutput {
    /// <p>The Amazon Resource Name (ARN) of the updated endpoint.</p>
    #[serde(rename = "EndpointArn")]
    pub endpoint_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateExperimentRequest {
    /// <p>The description of the experiment.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The name of the experiment as displayed. The name doesn't need to be unique. If <code>DisplayName</code> isn't specified, <code>ExperimentName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>The name of the experiment to update.</p>
    #[serde(rename = "ExperimentName")]
    pub experiment_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateExperimentResponse {
    /// <p>The Amazon Resource Name (ARN) of the experiment.</p>
    #[serde(rename = "ExperimentArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateImageRequest {
    /// <p>A list of properties to delete. Only the <code>Description</code> and <code>DisplayName</code> properties can be deleted.</p>
    #[serde(rename = "DeleteProperties")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub delete_properties: Option<Vec<String>>,
    /// <p>The new description for the image.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>The new display name for the image.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>The name of the image to update.</p>
    #[serde(rename = "ImageName")]
    pub image_name: String,
    /// <p>The new Amazon Resource Name (ARN) for the IAM role that enables Amazon SageMaker to perform tasks on your behalf.</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateImageResponse {
    /// <p>The Amazon Resource Name (ARN) of the image.</p>
    #[serde(rename = "ImageArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateModelPackageInput {
    /// <p>A description for the approval status of the model.</p>
    #[serde(rename = "ApprovalDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub approval_description: Option<String>,
    /// <p>The approval status of the model.</p>
    #[serde(rename = "ModelApprovalStatus")]
    pub model_approval_status: String,
    /// <p>The Amazon Resource Name (ARN) of the model.</p>
    #[serde(rename = "ModelPackageArn")]
    pub model_package_arn: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateModelPackageOutput {
    /// <p>The Amazon Resource Name (ARN) of the model.</p>
    #[serde(rename = "ModelPackageArn")]
    pub model_package_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateMonitoringScheduleRequest {
    /// <p>The configuration object that specifies the monitoring schedule and defines the monitoring job.</p>
    #[serde(rename = "MonitoringScheduleConfig")]
    pub monitoring_schedule_config: MonitoringScheduleConfig,
    /// <p>The name of the monitoring schedule. The name must be unique within an AWS Region within an AWS account.</p>
    #[serde(rename = "MonitoringScheduleName")]
    pub monitoring_schedule_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateMonitoringScheduleResponse {
    /// <p>The Amazon Resource Name (ARN) of the monitoring schedule.</p>
    #[serde(rename = "MonitoringScheduleArn")]
    pub monitoring_schedule_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateNotebookInstanceInput {
    /// <p>A list of the Elastic Inference (EI) instance types to associate with this notebook instance. Currently only one EI instance type can be associated with a notebook instance. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/ei.html">Using Elastic Inference in Amazon SageMaker</a>.</p>
    #[serde(rename = "AcceleratorTypes")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accelerator_types: Option<Vec<String>>,
    /// <p>An array of up to three Git repositories to associate with the notebook instance. These can be either the names of Git repositories stored as resources in your account, or the URL of Git repositories in <a href="https://docs.aws.amazon.com/codecommit/latest/userguide/welcome.html">AWS CodeCommit</a> or in any other Git repository. These repositories are cloned at the same level as the default repository of your notebook instance. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/nbi-git-repo.html">Associating Git Repositories with Amazon SageMaker Notebook Instances</a>.</p>
    #[serde(rename = "AdditionalCodeRepositories")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub additional_code_repositories: Option<Vec<String>>,
    /// <p>The Git repository to associate with the notebook instance as its default code repository. This can be either the name of a Git repository stored as a resource in your account, or the URL of a Git repository in <a href="https://docs.aws.amazon.com/codecommit/latest/userguide/welcome.html">AWS CodeCommit</a> or in any other Git repository. When you open a notebook instance, it opens in the directory that contains this repository. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/nbi-git-repo.html">Associating Git Repositories with Amazon SageMaker Notebook Instances</a>.</p>
    #[serde(rename = "DefaultCodeRepository")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_code_repository: Option<String>,
    /// <p>A list of the Elastic Inference (EI) instance types to remove from this notebook instance. This operation is idempotent. If you specify an accelerator type that is not associated with the notebook instance when you call this method, it does not throw an error.</p>
    #[serde(rename = "DisassociateAcceleratorTypes")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disassociate_accelerator_types: Option<bool>,
    /// <p>A list of names or URLs of the default Git repositories to remove from this notebook instance. This operation is idempotent. If you specify a Git repository that is not associated with the notebook instance when you call this method, it does not throw an error.</p>
    #[serde(rename = "DisassociateAdditionalCodeRepositories")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disassociate_additional_code_repositories: Option<bool>,
    /// <p>The name or URL of the default Git repository to remove from this notebook instance. This operation is idempotent. If you specify a Git repository that is not associated with the notebook instance when you call this method, it does not throw an error.</p>
    #[serde(rename = "DisassociateDefaultCodeRepository")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disassociate_default_code_repository: Option<bool>,
    /// <p>Set to <code>true</code> to remove the notebook instance lifecycle configuration currently associated with the notebook instance. This operation is idempotent. If you specify a lifecycle configuration that is not associated with the notebook instance when you call this method, it does not throw an error.</p>
    #[serde(rename = "DisassociateLifecycleConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disassociate_lifecycle_config: Option<bool>,
    /// <p>The Amazon ML compute instance type.</p>
    #[serde(rename = "InstanceType")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub instance_type: Option<String>,
    /// <p>The name of a lifecycle configuration to associate with the notebook instance. For information about lifestyle configurations, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/notebook-lifecycle-config.html">Step 2.1: (Optional) Customize a Notebook Instance</a>.</p>
    #[serde(rename = "LifecycleConfigName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lifecycle_config_name: Option<String>,
    /// <p>The name of the notebook instance to update.</p>
    #[serde(rename = "NotebookInstanceName")]
    pub notebook_instance_name: String,
    /// <p><p>The Amazon Resource Name (ARN) of the IAM role that Amazon SageMaker can assume to access the notebook instance. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html">Amazon SageMaker Roles</a>. </p> <note> <p>To be able to pass this role to Amazon SageMaker, the caller of this API must have the <code>iam:PassRole</code> permission.</p> </note></p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
    /// <p><p>Whether root access is enabled or disabled for users of the notebook instance. The default value is <code>Enabled</code>.</p> <note> <p>If you set this to <code>Disabled</code>, users don&#39;t have root access on the notebook instance, but lifecycle configuration scripts still run with root permissions.</p> </note></p>
    #[serde(rename = "RootAccess")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub root_access: Option<String>,
    /// <p>The size, in GB, of the ML storage volume to attach to the notebook instance. The default value is 5 GB. ML storage volumes are encrypted, so Amazon SageMaker can't determine the amount of available free space on the volume. Because of this, you can increase the volume size when you update a notebook instance, but you can't decrease the volume size. If you want to decrease the size of the ML storage volume in use, create a new notebook instance with the desired size.</p>
    #[serde(rename = "VolumeSizeInGB")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume_size_in_gb: Option<i64>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateNotebookInstanceLifecycleConfigInput {
    /// <p>The name of the lifecycle configuration.</p>
    #[serde(rename = "NotebookInstanceLifecycleConfigName")]
    pub notebook_instance_lifecycle_config_name: String,
    /// <p>The shell script that runs only once, when you create a notebook instance. The shell script must be a base64-encoded string.</p>
    #[serde(rename = "OnCreate")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub on_create: Option<Vec<NotebookInstanceLifecycleHook>>,
    /// <p>The shell script that runs every time you start a notebook instance, including when you create the notebook instance. The shell script must be a base64-encoded string.</p>
    #[serde(rename = "OnStart")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub on_start: Option<Vec<NotebookInstanceLifecycleHook>>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateNotebookInstanceLifecycleConfigOutput {}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateNotebookInstanceOutput {}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdatePipelineExecutionRequest {
    /// <p>The Amazon Resource Name (ARN) of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionArn")]
    pub pipeline_execution_arn: String,
    /// <p>The description of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_description: Option<String>,
    /// <p>The display name of the pipeline execution.</p>
    #[serde(rename = "PipelineExecutionDisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_display_name: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdatePipelineExecutionResponse {
    /// <p>The Amazon Resource Name (ARN) of the updated pipeline execution.</p>
    #[serde(rename = "PipelineExecutionArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_execution_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdatePipelineRequest {
    /// <p>The JSON pipeline definition.</p>
    #[serde(rename = "PipelineDefinition")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_definition: Option<String>,
    /// <p>The description of the pipeline.</p>
    #[serde(rename = "PipelineDescription")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_description: Option<String>,
    /// <p>The display name of the pipeline.</p>
    #[serde(rename = "PipelineDisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_display_name: Option<String>,
    /// <p>The name of the pipeline to update.</p>
    #[serde(rename = "PipelineName")]
    pub pipeline_name: String,
    /// <p>The Amazon Resource Name (ARN) that the pipeline uses to execute.</p>
    #[serde(rename = "RoleArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role_arn: Option<String>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdatePipelineResponse {
    /// <p>The Amazon Resource Name (ARN) of the updated pipeline.</p>
    #[serde(rename = "PipelineArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pipeline_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateTrainingJobRequest {
    /// <p>Configuration information for Debugger system monitoring, framework profiling, and storage paths.</p>
    #[serde(rename = "ProfilerConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub profiler_config: Option<ProfilerConfigForUpdate>,
    /// <p>Configuration information for Debugger rules for profiling system and framework metrics.</p>
    #[serde(rename = "ProfilerRuleConfigurations")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub profiler_rule_configurations: Option<Vec<ProfilerRuleConfiguration>>,
    /// <p>The name of a training job to update the Debugger profiling configuration.</p>
    #[serde(rename = "TrainingJobName")]
    pub training_job_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateTrainingJobResponse {
    /// <p>The Amazon Resource Name (ARN) of the training job.</p>
    #[serde(rename = "TrainingJobArn")]
    pub training_job_arn: String,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateTrialComponentRequest {
    /// <p>The name of the component as displayed. The name doesn't need to be unique. If <code>DisplayName</code> isn't specified, <code>TrialComponentName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>When the component ended.</p>
    #[serde(rename = "EndTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub end_time: Option<f64>,
    /// <p>Replaces all of the component's input artifacts with the specified artifacts.</p>
    #[serde(rename = "InputArtifacts")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_artifacts: Option<::std::collections::HashMap<String, TrialComponentArtifact>>,
    /// <p>The input artifacts to remove from the component.</p>
    #[serde(rename = "InputArtifactsToRemove")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_artifacts_to_remove: Option<Vec<String>>,
    /// <p>Replaces all of the component's output artifacts with the specified artifacts.</p>
    #[serde(rename = "OutputArtifacts")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_artifacts: Option<::std::collections::HashMap<String, TrialComponentArtifact>>,
    /// <p>The output artifacts to remove from the component.</p>
    #[serde(rename = "OutputArtifactsToRemove")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_artifacts_to_remove: Option<Vec<String>>,
    /// <p>Replaces all of the component's hyperparameters with the specified hyperparameters.</p>
    #[serde(rename = "Parameters")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parameters: Option<::std::collections::HashMap<String, TrialComponentParameterValue>>,
    /// <p>The hyperparameters to remove from the component.</p>
    #[serde(rename = "ParametersToRemove")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parameters_to_remove: Option<Vec<String>>,
    /// <p>When the component started.</p>
    #[serde(rename = "StartTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start_time: Option<f64>,
    /// <p>The new status of the component.</p>
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<TrialComponentStatus>,
    /// <p>The name of the component to update.</p>
    #[serde(rename = "TrialComponentName")]
    pub trial_component_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateTrialComponentResponse {
    /// <p>The Amazon Resource Name (ARN) of the trial component.</p>
    #[serde(rename = "TrialComponentArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_component_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateTrialRequest {
    /// <p>The name of the trial as displayed. The name doesn't need to be unique. If <code>DisplayName</code> isn't specified, <code>TrialName</code> is displayed.</p>
    #[serde(rename = "DisplayName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// <p>The name of the trial to update.</p>
    #[serde(rename = "TrialName")]
    pub trial_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateTrialResponse {
    /// <p>The Amazon Resource Name (ARN) of the trial.</p>
    #[serde(rename = "TrialArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trial_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateUserProfileRequest {
    /// <p>The domain ID.</p>
    #[serde(rename = "DomainId")]
    pub domain_id: String,
    /// <p>The user profile name.</p>
    #[serde(rename = "UserProfileName")]
    pub user_profile_name: String,
    /// <p>A collection of settings.</p>
    #[serde(rename = "UserSettings")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_settings: Option<UserSettings>,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateUserProfileResponse {
    /// <p>The user profile Amazon Resource Name (ARN).</p>
    #[serde(rename = "UserProfileArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_profile_arn: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateWorkforceRequest {
    /// <p>Use this parameter to update your OIDC Identity Provider (IdP) configuration for a workforce made using your own IdP.</p>
    #[serde(rename = "OidcConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub oidc_config: Option<OidcConfig>,
    /// <p>A list of one to ten worker IP address ranges (<a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html">CIDRs</a>) that can be used to access tasks assigned to this workforce.</p> <p>Maximum: Ten CIDR values</p>
    #[serde(rename = "SourceIpConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_ip_config: Option<SourceIpConfig>,
    /// <p>The name of the private workforce that you want to update. You can find your workforce name by using the operation.</p>
    #[serde(rename = "WorkforceName")]
    pub workforce_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateWorkforceResponse {
    /// <p>A single private workforce. You can create one private work force in each AWS 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 <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-create-private.html">Create a Private Workforce</a>.</p>
    #[serde(rename = "Workforce")]
    pub workforce: Workforce,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateWorkteamRequest {
    /// <p>An updated description for the work team.</p>
    #[serde(rename = "Description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// <p>A list of <code>MemberDefinition</code> objects that contains objects that identify the workers that make up the work team. </p> <p>Workforces can be created using Amazon Cognito or your own OIDC Identity Provider (IdP). For private workforces created using Amazon Cognito use <code>CognitoMemberDefinition</code>. For workforces created using your own OIDC identity provider (IdP) use <code>OidcMemberDefinition</code>. You should not provide input for both of these parameters in a single request.</p> <p>For workforces created using Amazon Cognito, private work teams correspond to Amazon Cognito <i>user groups</i> within the user pool used to create a workforce. All of the <code>CognitoMemberDefinition</code> objects that make up the member definition must have the same <code>ClientId</code> and <code>UserPool</code> values. To add a Amazon Cognito user group to an existing worker pool, see <a href="">Adding groups to a User Pool</a>. For more information about user pools, see <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html">Amazon Cognito User Pools</a>.</p> <p>For workforces created using your own OIDC IdP, specify the user groups that you want to include in your private work team in <code>OidcMemberDefinition</code> by listing those groups in <code>Groups</code>. Be aware that user groups that are already in the work team must also be listed in <code>Groups</code> when you make this request to remain on the work team. If you do not include these user groups, they will no longer be associated with the work team you update. </p>
    #[serde(rename = "MemberDefinitions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member_definitions: Option<Vec<MemberDefinition>>,
    /// <p>Configures SNS topic notifications for available or expiring work items</p>
    #[serde(rename = "NotificationConfiguration")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notification_configuration: Option<NotificationConfiguration>,
    /// <p>The name of the work team to update.</p>
    #[serde(rename = "WorkteamName")]
    pub workteam_name: String,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateWorkteamResponse {
    /// <p>A <code>Workteam</code> object that describes the updated work team.</p>
    #[serde(rename = "Workteam")]
    pub workteam: Workteam,
}

/// <p>Information about the user who created or modified an experiment, trial, or trial component.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UserContext {
    /// <p>The domain associated with the user.</p>
    #[serde(rename = "DomainId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_id: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the user's profile.</p>
    #[serde(rename = "UserProfileArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_profile_arn: Option<String>,
    /// <p>The name of the user's profile.</p>
    #[serde(rename = "UserProfileName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_profile_name: Option<String>,
}

/// <p>The user profile details.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UserProfileDetails {
    /// <p>The creation time.</p>
    #[serde(rename = "CreationTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_time: Option<f64>,
    /// <p>The domain ID.</p>
    #[serde(rename = "DomainId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_id: Option<String>,
    /// <p>The last modified time.</p>
    #[serde(rename = "LastModifiedTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified_time: Option<f64>,
    /// <p>The status.</p>
    #[serde(rename = "Status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    /// <p>The user profile name.</p>
    #[serde(rename = "UserProfileName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_profile_name: Option<String>,
}

/// <p>A collection of settings.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct UserSettings {
    /// <p>The execution role for the user.</p>
    #[serde(rename = "ExecutionRole")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub execution_role: Option<String>,
    /// <p>The Jupyter server's app settings.</p>
    #[serde(rename = "JupyterServerAppSettings")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jupyter_server_app_settings: Option<JupyterServerAppSettings>,
    /// <p>The kernel gateway app settings.</p>
    #[serde(rename = "KernelGatewayAppSettings")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kernel_gateway_app_settings: Option<KernelGatewayAppSettings>,
    /// <p>The security groups for the Amazon Virtual Private Cloud (VPC) that Studio uses for communication.</p> <p>Optional when the <code>CreateDomain.AppNetworkAccessType</code> parameter is set to <code>PublicInternetOnly</code>.</p> <p>Required when the <code>CreateDomain.AppNetworkAccessType</code> parameter is set to <code>VpcOnly</code>.</p>
    #[serde(rename = "SecurityGroups")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub security_groups: Option<Vec<String>>,
    /// <p>The sharing settings.</p>
    #[serde(rename = "SharingSettings")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sharing_settings: Option<SharingSettings>,
    /// <p>The TensorBoard app settings.</p>
    #[serde(rename = "TensorBoardAppSettings")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tensor_board_app_settings: Option<TensorBoardAppSettings>,
}

/// <p>Specifies a production variant property type for an Endpoint.</p> <p>If you are updating an endpoint with the <a>UpdateEndpointInput$RetainAllVariantProperties</a> option set to <code>true</code>, the <code>VariantProperty</code> objects listed in <a>UpdateEndpointInput$ExcludeRetainedVariantProperties</a> override the existing variant properties of the endpoint.</p>
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct VariantProperty {
    /// <p><p>The type of variant property. The supported values are:</p> <ul> <li> <p> <code>DesiredInstanceCount</code>: Overrides the existing variant instance counts using the <a>ProductionVariant$InitialInstanceCount</a> values in the <a>CreateEndpointConfigInput$ProductionVariants</a>.</p> </li> <li> <p> <code>DesiredWeight</code>: Overrides the existing variant weights using the <a>ProductionVariant$InitialVariantWeight</a> values in the <a>CreateEndpointConfigInput$ProductionVariants</a>.</p> </li> <li> <p> <code>DataCaptureConfig</code>: (Not currently supported.)</p> </li> </ul></p>
    #[serde(rename = "VariantPropertyType")]
    pub variant_property_type: String,
}

/// <p>Specifies a VPC that your training jobs and hosted models have access to. Control access to and from your training and model containers by configuring the VPC. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/host-vpc.html">Protect Endpoints by Using an Amazon Virtual Private Cloud</a> and <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/train-vpc.html">Protect Training Jobs by Using an Amazon Virtual Private Cloud</a>. </p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct VpcConfig {
    /// <p>The VPC security group IDs, in the form sg-xxxxxxxx. Specify the security groups for the VPC that is specified in the <code>Subnets</code> field.</p>
    #[serde(rename = "SecurityGroupIds")]
    pub security_group_ids: Vec<String>,
    /// <p>The ID of the subnets in the VPC to which you want to connect your training job or model. For information about the availability of specific instance types, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/instance-types-az.html">Supported Instance Types and Availability Zones</a>.</p>
    #[serde(rename = "Subnets")]
    pub subnets: Vec<String>,
}

/// <p>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 AWS 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 <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-create-private.html">Create a Private Workforce</a>.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Workforce {
    /// <p>The configuration of an Amazon Cognito workforce. A single Cognito workforce is created using and corresponds to a single <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html"> Amazon Cognito user pool</a>.</p>
    #[serde(rename = "CognitoConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cognito_config: Option<CognitoConfig>,
    /// <p>The date that the workforce is created.</p>
    #[serde(rename = "CreateDate")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub create_date: Option<f64>,
    /// <p>The most recent date that was used to successfully add one or more IP address ranges (<a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html">CIDRs</a>) to a private workforce's allow list.</p>
    #[serde(rename = "LastUpdatedDate")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_updated_date: Option<f64>,
    /// <p>The configuration of an OIDC Identity Provider (IdP) private workforce.</p>
    #[serde(rename = "OidcConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub oidc_config: Option<OidcConfigForResponse>,
    /// <p>A list of one to ten IP address ranges (<a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html">CIDRs</a>) to be added to the workforce allow list. By default, a workforce isn't restricted to specific IP addresses.</p>
    #[serde(rename = "SourceIpConfig")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_ip_config: Option<SourceIpConfig>,
    /// <p>The subdomain for your OIDC Identity Provider.</p>
    #[serde(rename = "SubDomain")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sub_domain: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the private workforce.</p>
    #[serde(rename = "WorkforceArn")]
    pub workforce_arn: String,
    /// <p>The name of the private workforce.</p>
    #[serde(rename = "WorkforceName")]
    pub workforce_name: String,
}

/// <p>Provides details about a labeling work team.</p>
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Workteam {
    /// <p>The date and time that the work team was created (timestamp).</p>
    #[serde(rename = "CreateDate")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub create_date: Option<f64>,
    /// <p>A description of the work team.</p>
    #[serde(rename = "Description")]
    pub description: String,
    /// <p>The date and time that the work team was last updated (timestamp).</p>
    #[serde(rename = "LastUpdatedDate")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_updated_date: Option<f64>,
    /// <p>A list of <code>MemberDefinition</code> objects that contains objects that identify the workers that make up the work team. </p> <p>Workforces can be created using Amazon Cognito or your own OIDC Identity Provider (IdP). For private workforces created using Amazon Cognito use <code>CognitoMemberDefinition</code>. For workforces created using your own OIDC identity provider (IdP) use <code>OidcMemberDefinition</code>.</p>
    #[serde(rename = "MemberDefinitions")]
    pub member_definitions: Vec<MemberDefinition>,
    /// <p>Configures SNS notifications of available or expiring work items for work teams.</p>
    #[serde(rename = "NotificationConfiguration")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notification_configuration: Option<NotificationConfiguration>,
    /// <p>The Amazon Marketplace identifier for a vendor's work team.</p>
    #[serde(rename = "ProductListingIds")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub product_listing_ids: Option<Vec<String>>,
    /// <p>The URI of the labeling job's user interface. Workers open this URI to start labeling your data objects.</p>
    #[serde(rename = "SubDomain")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sub_domain: Option<String>,
    /// <p>The Amazon Resource Name (ARN) of the workforce.</p>
    #[serde(rename = "WorkforceArn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub workforce_arn: Option<String>,
    /// <p>The Amazon Resource Name (ARN) that identifies the work team.</p>
    #[serde(rename = "WorkteamArn")]
    pub workteam_arn: String,
    /// <p>The name of the work team.</p>
    #[serde(rename = "WorkteamName")]
    pub workteam_name: String,
}

/// Errors returned by AddAssociation
#[derive(Debug, PartialEq)]
pub enum AddAssociationError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl AddAssociationError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddAssociationError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(AddAssociationError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(AddAssociationError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for AddAssociationError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            AddAssociationError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
            AddAssociationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for AddAssociationError {}
/// Errors returned by AddTags
#[derive(Debug, PartialEq)]
pub enum AddTagsError {}

impl AddTagsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddTagsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for AddTagsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for AddTagsError {}
/// Errors returned by AssociateTrialComponent
#[derive(Debug, PartialEq)]
pub enum AssociateTrialComponentError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl AssociateTrialComponentError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateTrialComponentError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        AssociateTrialComponentError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(AssociateTrialComponentError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for AssociateTrialComponentError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            AssociateTrialComponentError::ResourceLimitExceeded(ref cause) => {
                write!(f, "{}", cause)
            }
            AssociateTrialComponentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for AssociateTrialComponentError {}
/// Errors returned by CreateAction
#[derive(Debug, PartialEq)]
pub enum CreateActionError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateActionError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateActionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateActionError::ResourceLimitExceeded(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateActionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateActionError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateActionError {}
/// Errors returned by CreateAlgorithm
#[derive(Debug, PartialEq)]
pub enum CreateAlgorithmError {}

impl CreateAlgorithmError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateAlgorithmError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateAlgorithmError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for CreateAlgorithmError {}
/// Errors returned by CreateApp
#[derive(Debug, PartialEq)]
pub enum CreateAppError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateAppError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateAppError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateAppError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateAppError::ResourceLimitExceeded(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateAppError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateAppError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateAppError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateAppError {}
/// Errors returned by CreateAppImageConfig
#[derive(Debug, PartialEq)]
pub enum CreateAppImageConfigError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
}

impl CreateAppImageConfigError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateAppImageConfigError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateAppImageConfigError::ResourceInUse(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateAppImageConfigError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateAppImageConfigError::ResourceInUse(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateAppImageConfigError {}
/// Errors returned by CreateArtifact
#[derive(Debug, PartialEq)]
pub enum CreateArtifactError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateArtifactError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateArtifactError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateArtifactError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateArtifactError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateArtifactError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateArtifactError {}
/// Errors returned by CreateAutoMLJob
#[derive(Debug, PartialEq)]
pub enum CreateAutoMLJobError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateAutoMLJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateAutoMLJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateAutoMLJobError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateAutoMLJobError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateAutoMLJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateAutoMLJobError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateAutoMLJobError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateAutoMLJobError {}
/// Errors returned by CreateCodeRepository
#[derive(Debug, PartialEq)]
pub enum CreateCodeRepositoryError {}

impl CreateCodeRepositoryError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCodeRepositoryError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateCodeRepositoryError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for CreateCodeRepositoryError {}
/// Errors returned by CreateCompilationJob
#[derive(Debug, PartialEq)]
pub enum CreateCompilationJobError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateCompilationJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCompilationJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateCompilationJobError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateCompilationJobError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateCompilationJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateCompilationJobError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateCompilationJobError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateCompilationJobError {}
/// Errors returned by CreateContext
#[derive(Debug, PartialEq)]
pub enum CreateContextError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateContextError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateContextError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateContextError::ResourceLimitExceeded(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateContextError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateContextError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateContextError {}
/// Errors returned by CreateDataQualityJobDefinition
#[derive(Debug, PartialEq)]
pub enum CreateDataQualityJobDefinitionError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateDataQualityJobDefinitionError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<CreateDataQualityJobDefinitionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(
                        CreateDataQualityJobDefinitionError::ResourceInUse(err.msg),
                    )
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        CreateDataQualityJobDefinitionError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateDataQualityJobDefinitionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateDataQualityJobDefinitionError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateDataQualityJobDefinitionError::ResourceLimitExceeded(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for CreateDataQualityJobDefinitionError {}
/// Errors returned by CreateDeviceFleet
#[derive(Debug, PartialEq)]
pub enum CreateDeviceFleetError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateDeviceFleetError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDeviceFleetError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateDeviceFleetError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateDeviceFleetError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateDeviceFleetError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateDeviceFleetError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateDeviceFleetError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateDeviceFleetError {}
/// Errors returned by CreateDomain
#[derive(Debug, PartialEq)]
pub enum CreateDomainError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateDomainError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDomainError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateDomainError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateDomainError::ResourceLimitExceeded(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateDomainError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateDomainError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateDomainError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateDomainError {}
/// Errors returned by CreateEdgePackagingJob
#[derive(Debug, PartialEq)]
pub enum CreateEdgePackagingJobError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateEdgePackagingJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateEdgePackagingJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        CreateEdgePackagingJobError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateEdgePackagingJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateEdgePackagingJobError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateEdgePackagingJobError {}
/// Errors returned by CreateEndpoint
#[derive(Debug, PartialEq)]
pub enum CreateEndpointError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateEndpointError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateEndpointError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateEndpointError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateEndpointError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateEndpointError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateEndpointError {}
/// Errors returned by CreateEndpointConfig
#[derive(Debug, PartialEq)]
pub enum CreateEndpointConfigError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateEndpointConfigError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateEndpointConfigError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateEndpointConfigError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateEndpointConfigError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateEndpointConfigError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateEndpointConfigError {}
/// Errors returned by CreateExperiment
#[derive(Debug, PartialEq)]
pub enum CreateExperimentError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateExperimentError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateExperimentError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateExperimentError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateExperimentError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateExperimentError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateExperimentError {}
/// Errors returned by CreateFeatureGroup
#[derive(Debug, PartialEq)]
pub enum CreateFeatureGroupError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateFeatureGroupError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFeatureGroupError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateFeatureGroupError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateFeatureGroupError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateFeatureGroupError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateFeatureGroupError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateFeatureGroupError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateFeatureGroupError {}
/// Errors returned by CreateFlowDefinition
#[derive(Debug, PartialEq)]
pub enum CreateFlowDefinitionError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateFlowDefinitionError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFlowDefinitionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateFlowDefinitionError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateFlowDefinitionError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateFlowDefinitionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateFlowDefinitionError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateFlowDefinitionError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateFlowDefinitionError {}
/// Errors returned by CreateHumanTaskUi
#[derive(Debug, PartialEq)]
pub enum CreateHumanTaskUiError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateHumanTaskUiError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateHumanTaskUiError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateHumanTaskUiError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateHumanTaskUiError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateHumanTaskUiError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateHumanTaskUiError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateHumanTaskUiError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateHumanTaskUiError {}
/// Errors returned by CreateHyperParameterTuningJob
#[derive(Debug, PartialEq)]
pub enum CreateHyperParameterTuningJobError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateHyperParameterTuningJobError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<CreateHyperParameterTuningJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateHyperParameterTuningJobError::ResourceInUse(
                        err.msg,
                    ))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        CreateHyperParameterTuningJobError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateHyperParameterTuningJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateHyperParameterTuningJobError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateHyperParameterTuningJobError::ResourceLimitExceeded(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for CreateHyperParameterTuningJobError {}
/// Errors returned by CreateImage
#[derive(Debug, PartialEq)]
pub enum CreateImageError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateImageError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateImageError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateImageError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateImageError::ResourceLimitExceeded(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateImageError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateImageError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateImageError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateImageError {}
/// Errors returned by CreateImageVersion
#[derive(Debug, PartialEq)]
pub enum CreateImageVersionError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl CreateImageVersionError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateImageVersionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateImageVersionError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateImageVersionError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(CreateImageVersionError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateImageVersionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateImageVersionError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateImageVersionError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
            CreateImageVersionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateImageVersionError {}
/// Errors returned by CreateLabelingJob
#[derive(Debug, PartialEq)]
pub enum CreateLabelingJobError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateLabelingJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLabelingJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateLabelingJobError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateLabelingJobError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateLabelingJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateLabelingJobError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateLabelingJobError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateLabelingJobError {}
/// Errors returned by CreateModel
#[derive(Debug, PartialEq)]
pub enum CreateModelError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateModelError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateModelError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateModelError::ResourceLimitExceeded(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateModelError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateModelError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateModelError {}
/// Errors returned by CreateModelBiasJobDefinition
#[derive(Debug, PartialEq)]
pub enum CreateModelBiasJobDefinitionError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateModelBiasJobDefinitionError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<CreateModelBiasJobDefinitionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateModelBiasJobDefinitionError::ResourceInUse(
                        err.msg,
                    ))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        CreateModelBiasJobDefinitionError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateModelBiasJobDefinitionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateModelBiasJobDefinitionError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateModelBiasJobDefinitionError::ResourceLimitExceeded(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for CreateModelBiasJobDefinitionError {}
/// Errors returned by CreateModelExplainabilityJobDefinition
#[derive(Debug, PartialEq)]
pub enum CreateModelExplainabilityJobDefinitionError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateModelExplainabilityJobDefinitionError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<CreateModelExplainabilityJobDefinitionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(
                        CreateModelExplainabilityJobDefinitionError::ResourceInUse(err.msg),
                    )
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        CreateModelExplainabilityJobDefinitionError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateModelExplainabilityJobDefinitionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateModelExplainabilityJobDefinitionError::ResourceInUse(ref cause) => {
                write!(f, "{}", cause)
            }
            CreateModelExplainabilityJobDefinitionError::ResourceLimitExceeded(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for CreateModelExplainabilityJobDefinitionError {}
/// Errors returned by CreateModelPackage
#[derive(Debug, PartialEq)]
pub enum CreateModelPackageError {
    /// <p>There was a conflict when you attempted to modify an experiment, trial, or trial component.</p>
    Conflict(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateModelPackageError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateModelPackageError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ConflictException" => {
                    return RusotoError::Service(CreateModelPackageError::Conflict(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateModelPackageError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateModelPackageError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateModelPackageError::Conflict(ref cause) => write!(f, "{}", cause),
            CreateModelPackageError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateModelPackageError {}
/// Errors returned by CreateModelPackageGroup
#[derive(Debug, PartialEq)]
pub enum CreateModelPackageGroupError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateModelPackageGroupError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateModelPackageGroupError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        CreateModelPackageGroupError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateModelPackageGroupError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateModelPackageGroupError::ResourceLimitExceeded(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for CreateModelPackageGroupError {}
/// Errors returned by CreateModelQualityJobDefinition
#[derive(Debug, PartialEq)]
pub enum CreateModelQualityJobDefinitionError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateModelQualityJobDefinitionError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<CreateModelQualityJobDefinitionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(
                        CreateModelQualityJobDefinitionError::ResourceInUse(err.msg),
                    )
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        CreateModelQualityJobDefinitionError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateModelQualityJobDefinitionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateModelQualityJobDefinitionError::ResourceInUse(ref cause) => {
                write!(f, "{}", cause)
            }
            CreateModelQualityJobDefinitionError::ResourceLimitExceeded(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for CreateModelQualityJobDefinitionError {}
/// Errors returned by CreateMonitoringSchedule
#[derive(Debug, PartialEq)]
pub enum CreateMonitoringScheduleError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateMonitoringScheduleError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateMonitoringScheduleError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateMonitoringScheduleError::ResourceInUse(
                        err.msg,
                    ))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        CreateMonitoringScheduleError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateMonitoringScheduleError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateMonitoringScheduleError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateMonitoringScheduleError::ResourceLimitExceeded(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for CreateMonitoringScheduleError {}
/// Errors returned by CreateNotebookInstance
#[derive(Debug, PartialEq)]
pub enum CreateNotebookInstanceError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateNotebookInstanceError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateNotebookInstanceError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        CreateNotebookInstanceError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateNotebookInstanceError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateNotebookInstanceError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateNotebookInstanceError {}
/// Errors returned by CreateNotebookInstanceLifecycleConfig
#[derive(Debug, PartialEq)]
pub enum CreateNotebookInstanceLifecycleConfigError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateNotebookInstanceLifecycleConfigError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<CreateNotebookInstanceLifecycleConfigError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        CreateNotebookInstanceLifecycleConfigError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateNotebookInstanceLifecycleConfigError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateNotebookInstanceLifecycleConfigError::ResourceLimitExceeded(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for CreateNotebookInstanceLifecycleConfigError {}
/// Errors returned by CreatePipeline
#[derive(Debug, PartialEq)]
pub enum CreatePipelineError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl CreatePipelineError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreatePipelineError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreatePipelineError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(CreatePipelineError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreatePipelineError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreatePipelineError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
            CreatePipelineError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreatePipelineError {}
/// Errors returned by CreatePresignedDomainUrl
#[derive(Debug, PartialEq)]
pub enum CreatePresignedDomainUrlError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl CreatePresignedDomainUrlError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreatePresignedDomainUrlError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(CreatePresignedDomainUrlError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreatePresignedDomainUrlError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreatePresignedDomainUrlError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreatePresignedDomainUrlError {}
/// Errors returned by CreatePresignedNotebookInstanceUrl
#[derive(Debug, PartialEq)]
pub enum CreatePresignedNotebookInstanceUrlError {}

impl CreatePresignedNotebookInstanceUrlError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<CreatePresignedNotebookInstanceUrlError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreatePresignedNotebookInstanceUrlError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for CreatePresignedNotebookInstanceUrlError {}
/// Errors returned by CreateProcessingJob
#[derive(Debug, PartialEq)]
pub enum CreateProcessingJobError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl CreateProcessingJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateProcessingJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateProcessingJobError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateProcessingJobError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(CreateProcessingJobError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateProcessingJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateProcessingJobError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateProcessingJobError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
            CreateProcessingJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateProcessingJobError {}
/// Errors returned by CreateProject
#[derive(Debug, PartialEq)]
pub enum CreateProjectError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateProjectError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateProjectError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateProjectError::ResourceLimitExceeded(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateProjectError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateProjectError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateProjectError {}
/// Errors returned by CreateTrainingJob
#[derive(Debug, PartialEq)]
pub enum CreateTrainingJobError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl CreateTrainingJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTrainingJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateTrainingJobError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateTrainingJobError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(CreateTrainingJobError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateTrainingJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateTrainingJobError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateTrainingJobError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
            CreateTrainingJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateTrainingJobError {}
/// Errors returned by CreateTransformJob
#[derive(Debug, PartialEq)]
pub enum CreateTransformJobError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl CreateTransformJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTransformJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateTransformJobError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateTransformJobError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(CreateTransformJobError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateTransformJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateTransformJobError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateTransformJobError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
            CreateTransformJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateTransformJobError {}
/// Errors returned by CreateTrial
#[derive(Debug, PartialEq)]
pub enum CreateTrialError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl CreateTrialError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTrialError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateTrialError::ResourceLimitExceeded(err.msg))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(CreateTrialError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateTrialError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateTrialError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
            CreateTrialError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateTrialError {}
/// Errors returned by CreateTrialComponent
#[derive(Debug, PartialEq)]
pub enum CreateTrialComponentError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateTrialComponentError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTrialComponentError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateTrialComponentError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateTrialComponentError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateTrialComponentError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateTrialComponentError {}
/// Errors returned by CreateUserProfile
#[derive(Debug, PartialEq)]
pub enum CreateUserProfileError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateUserProfileError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateUserProfileError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateUserProfileError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateUserProfileError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateUserProfileError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateUserProfileError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateUserProfileError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateUserProfileError {}
/// Errors returned by CreateWorkforce
#[derive(Debug, PartialEq)]
pub enum CreateWorkforceError {}

impl CreateWorkforceError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateWorkforceError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateWorkforceError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for CreateWorkforceError {}
/// Errors returned by CreateWorkteam
#[derive(Debug, PartialEq)]
pub enum CreateWorkteamError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl CreateWorkteamError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateWorkteamError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(CreateWorkteamError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(CreateWorkteamError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for CreateWorkteamError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CreateWorkteamError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            CreateWorkteamError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for CreateWorkteamError {}
/// Errors returned by DeleteAction
#[derive(Debug, PartialEq)]
pub enum DeleteActionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteActionError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteActionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteActionError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteActionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteActionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteActionError {}
/// Errors returned by DeleteAlgorithm
#[derive(Debug, PartialEq)]
pub enum DeleteAlgorithmError {}

impl DeleteAlgorithmError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAlgorithmError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteAlgorithmError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DeleteAlgorithmError {}
/// Errors returned by DeleteApp
#[derive(Debug, PartialEq)]
pub enum DeleteAppError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteAppError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAppError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(DeleteAppError::ResourceInUse(err.msg))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteAppError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteAppError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteAppError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            DeleteAppError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteAppError {}
/// Errors returned by DeleteAppImageConfig
#[derive(Debug, PartialEq)]
pub enum DeleteAppImageConfigError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteAppImageConfigError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAppImageConfigError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteAppImageConfigError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteAppImageConfigError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteAppImageConfigError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteAppImageConfigError {}
/// Errors returned by DeleteArtifact
#[derive(Debug, PartialEq)]
pub enum DeleteArtifactError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteArtifactError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteArtifactError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteArtifactError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteArtifactError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteArtifactError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteArtifactError {}
/// Errors returned by DeleteAssociation
#[derive(Debug, PartialEq)]
pub enum DeleteAssociationError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteAssociationError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAssociationError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteAssociationError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteAssociationError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteAssociationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteAssociationError {}
/// Errors returned by DeleteCodeRepository
#[derive(Debug, PartialEq)]
pub enum DeleteCodeRepositoryError {}

impl DeleteCodeRepositoryError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteCodeRepositoryError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteCodeRepositoryError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DeleteCodeRepositoryError {}
/// Errors returned by DeleteContext
#[derive(Debug, PartialEq)]
pub enum DeleteContextError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteContextError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteContextError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteContextError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteContextError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteContextError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteContextError {}
/// Errors returned by DeleteDataQualityJobDefinition
#[derive(Debug, PartialEq)]
pub enum DeleteDataQualityJobDefinitionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteDataQualityJobDefinitionError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DeleteDataQualityJobDefinitionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(
                        DeleteDataQualityJobDefinitionError::ResourceNotFound(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteDataQualityJobDefinitionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteDataQualityJobDefinitionError::ResourceNotFound(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for DeleteDataQualityJobDefinitionError {}
/// Errors returned by DeleteDeviceFleet
#[derive(Debug, PartialEq)]
pub enum DeleteDeviceFleetError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
}

impl DeleteDeviceFleetError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDeviceFleetError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(DeleteDeviceFleetError::ResourceInUse(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteDeviceFleetError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteDeviceFleetError::ResourceInUse(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteDeviceFleetError {}
/// Errors returned by DeleteDomain
#[derive(Debug, PartialEq)]
pub enum DeleteDomainError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteDomainError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDomainError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(DeleteDomainError::ResourceInUse(err.msg))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteDomainError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteDomainError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteDomainError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            DeleteDomainError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteDomainError {}
/// Errors returned by DeleteEndpoint
#[derive(Debug, PartialEq)]
pub enum DeleteEndpointError {}

impl DeleteEndpointError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteEndpointError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteEndpointError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DeleteEndpointError {}
/// Errors returned by DeleteEndpointConfig
#[derive(Debug, PartialEq)]
pub enum DeleteEndpointConfigError {}

impl DeleteEndpointConfigError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteEndpointConfigError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteEndpointConfigError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DeleteEndpointConfigError {}
/// Errors returned by DeleteExperiment
#[derive(Debug, PartialEq)]
pub enum DeleteExperimentError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteExperimentError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteExperimentError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteExperimentError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteExperimentError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteExperimentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteExperimentError {}
/// Errors returned by DeleteFeatureGroup
#[derive(Debug, PartialEq)]
pub enum DeleteFeatureGroupError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteFeatureGroupError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFeatureGroupError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteFeatureGroupError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteFeatureGroupError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteFeatureGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteFeatureGroupError {}
/// Errors returned by DeleteFlowDefinition
#[derive(Debug, PartialEq)]
pub enum DeleteFlowDefinitionError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteFlowDefinitionError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFlowDefinitionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(DeleteFlowDefinitionError::ResourceInUse(err.msg))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteFlowDefinitionError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteFlowDefinitionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteFlowDefinitionError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            DeleteFlowDefinitionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteFlowDefinitionError {}
/// Errors returned by DeleteHumanTaskUi
#[derive(Debug, PartialEq)]
pub enum DeleteHumanTaskUiError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteHumanTaskUiError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteHumanTaskUiError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteHumanTaskUiError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteHumanTaskUiError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteHumanTaskUiError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteHumanTaskUiError {}
/// Errors returned by DeleteImage
#[derive(Debug, PartialEq)]
pub enum DeleteImageError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteImageError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteImageError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(DeleteImageError::ResourceInUse(err.msg))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteImageError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteImageError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteImageError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            DeleteImageError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteImageError {}
/// Errors returned by DeleteImageVersion
#[derive(Debug, PartialEq)]
pub enum DeleteImageVersionError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteImageVersionError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteImageVersionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(DeleteImageVersionError::ResourceInUse(err.msg))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteImageVersionError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteImageVersionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteImageVersionError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            DeleteImageVersionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteImageVersionError {}
/// Errors returned by DeleteModel
#[derive(Debug, PartialEq)]
pub enum DeleteModelError {}

impl DeleteModelError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteModelError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteModelError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DeleteModelError {}
/// Errors returned by DeleteModelBiasJobDefinition
#[derive(Debug, PartialEq)]
pub enum DeleteModelBiasJobDefinitionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteModelBiasJobDefinitionError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DeleteModelBiasJobDefinitionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(
                        DeleteModelBiasJobDefinitionError::ResourceNotFound(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteModelBiasJobDefinitionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteModelBiasJobDefinitionError::ResourceNotFound(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for DeleteModelBiasJobDefinitionError {}
/// Errors returned by DeleteModelExplainabilityJobDefinition
#[derive(Debug, PartialEq)]
pub enum DeleteModelExplainabilityJobDefinitionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteModelExplainabilityJobDefinitionError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DeleteModelExplainabilityJobDefinitionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(
                        DeleteModelExplainabilityJobDefinitionError::ResourceNotFound(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteModelExplainabilityJobDefinitionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteModelExplainabilityJobDefinitionError::ResourceNotFound(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for DeleteModelExplainabilityJobDefinitionError {}
/// Errors returned by DeleteModelPackage
#[derive(Debug, PartialEq)]
pub enum DeleteModelPackageError {
    /// <p>There was a conflict when you attempted to modify an experiment, trial, or trial component.</p>
    Conflict(String),
}

impl DeleteModelPackageError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteModelPackageError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ConflictException" => {
                    return RusotoError::Service(DeleteModelPackageError::Conflict(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteModelPackageError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteModelPackageError::Conflict(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteModelPackageError {}
/// Errors returned by DeleteModelPackageGroup
#[derive(Debug, PartialEq)]
pub enum DeleteModelPackageGroupError {}

impl DeleteModelPackageGroupError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteModelPackageGroupError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteModelPackageGroupError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DeleteModelPackageGroupError {}
/// Errors returned by DeleteModelPackageGroupPolicy
#[derive(Debug, PartialEq)]
pub enum DeleteModelPackageGroupPolicyError {}

impl DeleteModelPackageGroupPolicyError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DeleteModelPackageGroupPolicyError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteModelPackageGroupPolicyError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DeleteModelPackageGroupPolicyError {}
/// Errors returned by DeleteModelQualityJobDefinition
#[derive(Debug, PartialEq)]
pub enum DeleteModelQualityJobDefinitionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteModelQualityJobDefinitionError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DeleteModelQualityJobDefinitionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(
                        DeleteModelQualityJobDefinitionError::ResourceNotFound(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteModelQualityJobDefinitionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteModelQualityJobDefinitionError::ResourceNotFound(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for DeleteModelQualityJobDefinitionError {}
/// Errors returned by DeleteMonitoringSchedule
#[derive(Debug, PartialEq)]
pub enum DeleteMonitoringScheduleError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteMonitoringScheduleError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteMonitoringScheduleError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteMonitoringScheduleError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteMonitoringScheduleError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteMonitoringScheduleError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteMonitoringScheduleError {}
/// Errors returned by DeleteNotebookInstance
#[derive(Debug, PartialEq)]
pub enum DeleteNotebookInstanceError {}

impl DeleteNotebookInstanceError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteNotebookInstanceError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteNotebookInstanceError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DeleteNotebookInstanceError {}
/// Errors returned by DeleteNotebookInstanceLifecycleConfig
#[derive(Debug, PartialEq)]
pub enum DeleteNotebookInstanceLifecycleConfigError {}

impl DeleteNotebookInstanceLifecycleConfigError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DeleteNotebookInstanceLifecycleConfigError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteNotebookInstanceLifecycleConfigError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DeleteNotebookInstanceLifecycleConfigError {}
/// Errors returned by DeletePipeline
#[derive(Debug, PartialEq)]
pub enum DeletePipelineError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeletePipelineError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeletePipelineError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DeletePipelineError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeletePipelineError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeletePipelineError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeletePipelineError {}
/// Errors returned by DeleteProject
#[derive(Debug, PartialEq)]
pub enum DeleteProjectError {}

impl DeleteProjectError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteProjectError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteProjectError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DeleteProjectError {}
/// Errors returned by DeleteTags
#[derive(Debug, PartialEq)]
pub enum DeleteTagsError {}

impl DeleteTagsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTagsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteTagsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DeleteTagsError {}
/// Errors returned by DeleteTrial
#[derive(Debug, PartialEq)]
pub enum DeleteTrialError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteTrialError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTrialError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteTrialError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteTrialError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteTrialError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteTrialError {}
/// Errors returned by DeleteTrialComponent
#[derive(Debug, PartialEq)]
pub enum DeleteTrialComponentError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteTrialComponentError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTrialComponentError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteTrialComponentError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteTrialComponentError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteTrialComponentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteTrialComponentError {}
/// Errors returned by DeleteUserProfile
#[derive(Debug, PartialEq)]
pub enum DeleteUserProfileError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DeleteUserProfileError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteUserProfileError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(DeleteUserProfileError::ResourceInUse(err.msg))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(DeleteUserProfileError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteUserProfileError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteUserProfileError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            DeleteUserProfileError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteUserProfileError {}
/// Errors returned by DeleteWorkforce
#[derive(Debug, PartialEq)]
pub enum DeleteWorkforceError {}

impl DeleteWorkforceError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteWorkforceError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteWorkforceError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DeleteWorkforceError {}
/// Errors returned by DeleteWorkteam
#[derive(Debug, PartialEq)]
pub enum DeleteWorkteamError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl DeleteWorkteamError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteWorkteamError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(DeleteWorkteamError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeleteWorkteamError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DeleteWorkteamError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DeleteWorkteamError {}
/// Errors returned by DeregisterDevices
#[derive(Debug, PartialEq)]
pub enum DeregisterDevicesError {}

impl DeregisterDevicesError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeregisterDevicesError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DeregisterDevicesError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DeregisterDevicesError {}
/// Errors returned by DescribeAction
#[derive(Debug, PartialEq)]
pub enum DescribeActionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeActionError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeActionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeActionError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeActionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeActionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeActionError {}
/// Errors returned by DescribeAlgorithm
#[derive(Debug, PartialEq)]
pub enum DescribeAlgorithmError {}

impl DescribeAlgorithmError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAlgorithmError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeAlgorithmError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DescribeAlgorithmError {}
/// Errors returned by DescribeApp
#[derive(Debug, PartialEq)]
pub enum DescribeAppError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeAppError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAppError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeAppError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeAppError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeAppError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeAppError {}
/// Errors returned by DescribeAppImageConfig
#[derive(Debug, PartialEq)]
pub enum DescribeAppImageConfigError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeAppImageConfigError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAppImageConfigError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeAppImageConfigError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeAppImageConfigError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeAppImageConfigError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeAppImageConfigError {}
/// Errors returned by DescribeArtifact
#[derive(Debug, PartialEq)]
pub enum DescribeArtifactError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeArtifactError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeArtifactError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeArtifactError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeArtifactError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeArtifactError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeArtifactError {}
/// Errors returned by DescribeAutoMLJob
#[derive(Debug, PartialEq)]
pub enum DescribeAutoMLJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeAutoMLJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAutoMLJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeAutoMLJobError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeAutoMLJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeAutoMLJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeAutoMLJobError {}
/// Errors returned by DescribeCodeRepository
#[derive(Debug, PartialEq)]
pub enum DescribeCodeRepositoryError {}

impl DescribeCodeRepositoryError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeCodeRepositoryError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeCodeRepositoryError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DescribeCodeRepositoryError {}
/// Errors returned by DescribeCompilationJob
#[derive(Debug, PartialEq)]
pub enum DescribeCompilationJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeCompilationJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeCompilationJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeCompilationJobError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeCompilationJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeCompilationJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeCompilationJobError {}
/// Errors returned by DescribeContext
#[derive(Debug, PartialEq)]
pub enum DescribeContextError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeContextError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeContextError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeContextError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeContextError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeContextError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeContextError {}
/// Errors returned by DescribeDataQualityJobDefinition
#[derive(Debug, PartialEq)]
pub enum DescribeDataQualityJobDefinitionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeDataQualityJobDefinitionError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DescribeDataQualityJobDefinitionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(
                        DescribeDataQualityJobDefinitionError::ResourceNotFound(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeDataQualityJobDefinitionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeDataQualityJobDefinitionError::ResourceNotFound(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for DescribeDataQualityJobDefinitionError {}
/// Errors returned by DescribeDevice
#[derive(Debug, PartialEq)]
pub enum DescribeDeviceError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeDeviceError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDeviceError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeDeviceError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeDeviceError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeDeviceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeDeviceError {}
/// Errors returned by DescribeDeviceFleet
#[derive(Debug, PartialEq)]
pub enum DescribeDeviceFleetError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeDeviceFleetError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDeviceFleetError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeDeviceFleetError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeDeviceFleetError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeDeviceFleetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeDeviceFleetError {}
/// Errors returned by DescribeDomain
#[derive(Debug, PartialEq)]
pub enum DescribeDomainError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeDomainError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDomainError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeDomainError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeDomainError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeDomainError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeDomainError {}
/// Errors returned by DescribeEdgePackagingJob
#[derive(Debug, PartialEq)]
pub enum DescribeEdgePackagingJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeEdgePackagingJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeEdgePackagingJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeEdgePackagingJobError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeEdgePackagingJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeEdgePackagingJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeEdgePackagingJobError {}
/// Errors returned by DescribeEndpoint
#[derive(Debug, PartialEq)]
pub enum DescribeEndpointError {}

impl DescribeEndpointError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeEndpointError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeEndpointError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DescribeEndpointError {}
/// Errors returned by DescribeEndpointConfig
#[derive(Debug, PartialEq)]
pub enum DescribeEndpointConfigError {}

impl DescribeEndpointConfigError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeEndpointConfigError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeEndpointConfigError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DescribeEndpointConfigError {}
/// Errors returned by DescribeExperiment
#[derive(Debug, PartialEq)]
pub enum DescribeExperimentError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeExperimentError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeExperimentError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeExperimentError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeExperimentError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeExperimentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeExperimentError {}
/// Errors returned by DescribeFeatureGroup
#[derive(Debug, PartialEq)]
pub enum DescribeFeatureGroupError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeFeatureGroupError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeFeatureGroupError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeFeatureGroupError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeFeatureGroupError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeFeatureGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeFeatureGroupError {}
/// Errors returned by DescribeFlowDefinition
#[derive(Debug, PartialEq)]
pub enum DescribeFlowDefinitionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeFlowDefinitionError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeFlowDefinitionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeFlowDefinitionError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeFlowDefinitionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeFlowDefinitionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeFlowDefinitionError {}
/// Errors returned by DescribeHumanTaskUi
#[derive(Debug, PartialEq)]
pub enum DescribeHumanTaskUiError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeHumanTaskUiError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeHumanTaskUiError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeHumanTaskUiError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeHumanTaskUiError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeHumanTaskUiError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeHumanTaskUiError {}
/// Errors returned by DescribeHyperParameterTuningJob
#[derive(Debug, PartialEq)]
pub enum DescribeHyperParameterTuningJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeHyperParameterTuningJobError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DescribeHyperParameterTuningJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(
                        DescribeHyperParameterTuningJobError::ResourceNotFound(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeHyperParameterTuningJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeHyperParameterTuningJobError::ResourceNotFound(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for DescribeHyperParameterTuningJobError {}
/// Errors returned by DescribeImage
#[derive(Debug, PartialEq)]
pub enum DescribeImageError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeImageError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeImageError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeImageError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeImageError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeImageError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeImageError {}
/// Errors returned by DescribeImageVersion
#[derive(Debug, PartialEq)]
pub enum DescribeImageVersionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeImageVersionError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeImageVersionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeImageVersionError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeImageVersionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeImageVersionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeImageVersionError {}
/// Errors returned by DescribeLabelingJob
#[derive(Debug, PartialEq)]
pub enum DescribeLabelingJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeLabelingJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeLabelingJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeLabelingJobError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeLabelingJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeLabelingJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeLabelingJobError {}
/// Errors returned by DescribeModel
#[derive(Debug, PartialEq)]
pub enum DescribeModelError {}

impl DescribeModelError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeModelError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeModelError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DescribeModelError {}
/// Errors returned by DescribeModelBiasJobDefinition
#[derive(Debug, PartialEq)]
pub enum DescribeModelBiasJobDefinitionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeModelBiasJobDefinitionError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DescribeModelBiasJobDefinitionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(
                        DescribeModelBiasJobDefinitionError::ResourceNotFound(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeModelBiasJobDefinitionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeModelBiasJobDefinitionError::ResourceNotFound(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for DescribeModelBiasJobDefinitionError {}
/// Errors returned by DescribeModelExplainabilityJobDefinition
#[derive(Debug, PartialEq)]
pub enum DescribeModelExplainabilityJobDefinitionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeModelExplainabilityJobDefinitionError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DescribeModelExplainabilityJobDefinitionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(
                        DescribeModelExplainabilityJobDefinitionError::ResourceNotFound(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeModelExplainabilityJobDefinitionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeModelExplainabilityJobDefinitionError::ResourceNotFound(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for DescribeModelExplainabilityJobDefinitionError {}
/// Errors returned by DescribeModelPackage
#[derive(Debug, PartialEq)]
pub enum DescribeModelPackageError {}

impl DescribeModelPackageError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeModelPackageError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeModelPackageError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DescribeModelPackageError {}
/// Errors returned by DescribeModelPackageGroup
#[derive(Debug, PartialEq)]
pub enum DescribeModelPackageGroupError {}

impl DescribeModelPackageGroupError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeModelPackageGroupError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeModelPackageGroupError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DescribeModelPackageGroupError {}
/// Errors returned by DescribeModelQualityJobDefinition
#[derive(Debug, PartialEq)]
pub enum DescribeModelQualityJobDefinitionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeModelQualityJobDefinitionError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DescribeModelQualityJobDefinitionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(
                        DescribeModelQualityJobDefinitionError::ResourceNotFound(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeModelQualityJobDefinitionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeModelQualityJobDefinitionError::ResourceNotFound(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for DescribeModelQualityJobDefinitionError {}
/// Errors returned by DescribeMonitoringSchedule
#[derive(Debug, PartialEq)]
pub enum DescribeMonitoringScheduleError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeMonitoringScheduleError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DescribeMonitoringScheduleError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeMonitoringScheduleError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeMonitoringScheduleError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeMonitoringScheduleError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeMonitoringScheduleError {}
/// Errors returned by DescribeNotebookInstance
#[derive(Debug, PartialEq)]
pub enum DescribeNotebookInstanceError {}

impl DescribeNotebookInstanceError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeNotebookInstanceError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeNotebookInstanceError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DescribeNotebookInstanceError {}
/// Errors returned by DescribeNotebookInstanceLifecycleConfig
#[derive(Debug, PartialEq)]
pub enum DescribeNotebookInstanceLifecycleConfigError {}

impl DescribeNotebookInstanceLifecycleConfigError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DescribeNotebookInstanceLifecycleConfigError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeNotebookInstanceLifecycleConfigError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DescribeNotebookInstanceLifecycleConfigError {}
/// Errors returned by DescribePipeline
#[derive(Debug, PartialEq)]
pub enum DescribePipelineError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribePipelineError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribePipelineError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribePipelineError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribePipelineError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribePipelineError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribePipelineError {}
/// Errors returned by DescribePipelineDefinitionForExecution
#[derive(Debug, PartialEq)]
pub enum DescribePipelineDefinitionForExecutionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribePipelineDefinitionForExecutionError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DescribePipelineDefinitionForExecutionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(
                        DescribePipelineDefinitionForExecutionError::ResourceNotFound(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribePipelineDefinitionForExecutionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribePipelineDefinitionForExecutionError::ResourceNotFound(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for DescribePipelineDefinitionForExecutionError {}
/// Errors returned by DescribePipelineExecution
#[derive(Debug, PartialEq)]
pub enum DescribePipelineExecutionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribePipelineExecutionError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribePipelineExecutionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribePipelineExecutionError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribePipelineExecutionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribePipelineExecutionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribePipelineExecutionError {}
/// Errors returned by DescribeProcessingJob
#[derive(Debug, PartialEq)]
pub enum DescribeProcessingJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeProcessingJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeProcessingJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeProcessingJobError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeProcessingJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeProcessingJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeProcessingJobError {}
/// Errors returned by DescribeProject
#[derive(Debug, PartialEq)]
pub enum DescribeProjectError {}

impl DescribeProjectError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeProjectError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeProjectError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DescribeProjectError {}
/// Errors returned by DescribeSubscribedWorkteam
#[derive(Debug, PartialEq)]
pub enum DescribeSubscribedWorkteamError {}

impl DescribeSubscribedWorkteamError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DescribeSubscribedWorkteamError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeSubscribedWorkteamError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DescribeSubscribedWorkteamError {}
/// Errors returned by DescribeTrainingJob
#[derive(Debug, PartialEq)]
pub enum DescribeTrainingJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeTrainingJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTrainingJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeTrainingJobError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeTrainingJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeTrainingJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeTrainingJobError {}
/// Errors returned by DescribeTransformJob
#[derive(Debug, PartialEq)]
pub enum DescribeTransformJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeTransformJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTransformJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeTransformJobError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeTransformJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeTransformJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeTransformJobError {}
/// Errors returned by DescribeTrial
#[derive(Debug, PartialEq)]
pub enum DescribeTrialError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeTrialError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTrialError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeTrialError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeTrialError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeTrialError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeTrialError {}
/// Errors returned by DescribeTrialComponent
#[derive(Debug, PartialEq)]
pub enum DescribeTrialComponentError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeTrialComponentError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTrialComponentError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeTrialComponentError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeTrialComponentError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeTrialComponentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeTrialComponentError {}
/// Errors returned by DescribeUserProfile
#[derive(Debug, PartialEq)]
pub enum DescribeUserProfileError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DescribeUserProfileError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeUserProfileError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DescribeUserProfileError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeUserProfileError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DescribeUserProfileError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DescribeUserProfileError {}
/// Errors returned by DescribeWorkforce
#[derive(Debug, PartialEq)]
pub enum DescribeWorkforceError {}

impl DescribeWorkforceError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeWorkforceError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeWorkforceError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DescribeWorkforceError {}
/// Errors returned by DescribeWorkteam
#[derive(Debug, PartialEq)]
pub enum DescribeWorkteamError {}

impl DescribeWorkteamError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeWorkteamError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DescribeWorkteamError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DescribeWorkteamError {}
/// Errors returned by DisableSagemakerServicecatalogPortfolio
#[derive(Debug, PartialEq)]
pub enum DisableSagemakerServicecatalogPortfolioError {}

impl DisableSagemakerServicecatalogPortfolioError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DisableSagemakerServicecatalogPortfolioError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DisableSagemakerServicecatalogPortfolioError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for DisableSagemakerServicecatalogPortfolioError {}
/// Errors returned by DisassociateTrialComponent
#[derive(Debug, PartialEq)]
pub enum DisassociateTrialComponentError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl DisassociateTrialComponentError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<DisassociateTrialComponentError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(DisassociateTrialComponentError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for DisassociateTrialComponentError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DisassociateTrialComponentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for DisassociateTrialComponentError {}
/// Errors returned by EnableSagemakerServicecatalogPortfolio
#[derive(Debug, PartialEq)]
pub enum EnableSagemakerServicecatalogPortfolioError {}

impl EnableSagemakerServicecatalogPortfolioError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<EnableSagemakerServicecatalogPortfolioError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for EnableSagemakerServicecatalogPortfolioError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for EnableSagemakerServicecatalogPortfolioError {}
/// Errors returned by GetDeviceFleetReport
#[derive(Debug, PartialEq)]
pub enum GetDeviceFleetReportError {}

impl GetDeviceFleetReportError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDeviceFleetReportError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for GetDeviceFleetReportError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for GetDeviceFleetReportError {}
/// Errors returned by GetModelPackageGroupPolicy
#[derive(Debug, PartialEq)]
pub enum GetModelPackageGroupPolicyError {}

impl GetModelPackageGroupPolicyError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<GetModelPackageGroupPolicyError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for GetModelPackageGroupPolicyError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for GetModelPackageGroupPolicyError {}
/// Errors returned by GetSagemakerServicecatalogPortfolioStatus
#[derive(Debug, PartialEq)]
pub enum GetSagemakerServicecatalogPortfolioStatusError {}

impl GetSagemakerServicecatalogPortfolioStatusError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<GetSagemakerServicecatalogPortfolioStatusError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for GetSagemakerServicecatalogPortfolioStatusError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for GetSagemakerServicecatalogPortfolioStatusError {}
/// Errors returned by GetSearchSuggestions
#[derive(Debug, PartialEq)]
pub enum GetSearchSuggestionsError {}

impl GetSearchSuggestionsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSearchSuggestionsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for GetSearchSuggestionsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for GetSearchSuggestionsError {}
/// Errors returned by ListActions
#[derive(Debug, PartialEq)]
pub enum ListActionsError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl ListActionsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListActionsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(ListActionsError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListActionsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ListActionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for ListActionsError {}
/// Errors returned by ListAlgorithms
#[derive(Debug, PartialEq)]
pub enum ListAlgorithmsError {}

impl ListAlgorithmsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAlgorithmsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListAlgorithmsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListAlgorithmsError {}
/// Errors returned by ListAppImageConfigs
#[derive(Debug, PartialEq)]
pub enum ListAppImageConfigsError {}

impl ListAppImageConfigsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAppImageConfigsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListAppImageConfigsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListAppImageConfigsError {}
/// Errors returned by ListApps
#[derive(Debug, PartialEq)]
pub enum ListAppsError {}

impl ListAppsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAppsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListAppsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListAppsError {}
/// Errors returned by ListArtifacts
#[derive(Debug, PartialEq)]
pub enum ListArtifactsError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl ListArtifactsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListArtifactsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(ListArtifactsError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListArtifactsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ListArtifactsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for ListArtifactsError {}
/// Errors returned by ListAssociations
#[derive(Debug, PartialEq)]
pub enum ListAssociationsError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl ListAssociationsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAssociationsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(ListAssociationsError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListAssociationsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ListAssociationsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for ListAssociationsError {}
/// Errors returned by ListAutoMLJobs
#[derive(Debug, PartialEq)]
pub enum ListAutoMLJobsError {}

impl ListAutoMLJobsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAutoMLJobsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListAutoMLJobsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListAutoMLJobsError {}
/// Errors returned by ListCandidatesForAutoMLJob
#[derive(Debug, PartialEq)]
pub enum ListCandidatesForAutoMLJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl ListCandidatesForAutoMLJobError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<ListCandidatesForAutoMLJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(ListCandidatesForAutoMLJobError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListCandidatesForAutoMLJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ListCandidatesForAutoMLJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for ListCandidatesForAutoMLJobError {}
/// Errors returned by ListCodeRepositories
#[derive(Debug, PartialEq)]
pub enum ListCodeRepositoriesError {}

impl ListCodeRepositoriesError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListCodeRepositoriesError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListCodeRepositoriesError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListCodeRepositoriesError {}
/// Errors returned by ListCompilationJobs
#[derive(Debug, PartialEq)]
pub enum ListCompilationJobsError {}

impl ListCompilationJobsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListCompilationJobsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListCompilationJobsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListCompilationJobsError {}
/// Errors returned by ListContexts
#[derive(Debug, PartialEq)]
pub enum ListContextsError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl ListContextsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListContextsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(ListContextsError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListContextsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ListContextsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for ListContextsError {}
/// Errors returned by ListDataQualityJobDefinitions
#[derive(Debug, PartialEq)]
pub enum ListDataQualityJobDefinitionsError {}

impl ListDataQualityJobDefinitionsError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<ListDataQualityJobDefinitionsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListDataQualityJobDefinitionsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListDataQualityJobDefinitionsError {}
/// Errors returned by ListDeviceFleets
#[derive(Debug, PartialEq)]
pub enum ListDeviceFleetsError {}

impl ListDeviceFleetsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDeviceFleetsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListDeviceFleetsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListDeviceFleetsError {}
/// Errors returned by ListDevices
#[derive(Debug, PartialEq)]
pub enum ListDevicesError {}

impl ListDevicesError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDevicesError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListDevicesError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListDevicesError {}
/// Errors returned by ListDomains
#[derive(Debug, PartialEq)]
pub enum ListDomainsError {}

impl ListDomainsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDomainsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListDomainsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListDomainsError {}
/// Errors returned by ListEdgePackagingJobs
#[derive(Debug, PartialEq)]
pub enum ListEdgePackagingJobsError {}

impl ListEdgePackagingJobsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListEdgePackagingJobsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListEdgePackagingJobsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListEdgePackagingJobsError {}
/// Errors returned by ListEndpointConfigs
#[derive(Debug, PartialEq)]
pub enum ListEndpointConfigsError {}

impl ListEndpointConfigsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListEndpointConfigsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListEndpointConfigsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListEndpointConfigsError {}
/// Errors returned by ListEndpoints
#[derive(Debug, PartialEq)]
pub enum ListEndpointsError {}

impl ListEndpointsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListEndpointsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListEndpointsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListEndpointsError {}
/// Errors returned by ListExperiments
#[derive(Debug, PartialEq)]
pub enum ListExperimentsError {}

impl ListExperimentsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListExperimentsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListExperimentsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListExperimentsError {}
/// Errors returned by ListFeatureGroups
#[derive(Debug, PartialEq)]
pub enum ListFeatureGroupsError {}

impl ListFeatureGroupsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFeatureGroupsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListFeatureGroupsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListFeatureGroupsError {}
/// Errors returned by ListFlowDefinitions
#[derive(Debug, PartialEq)]
pub enum ListFlowDefinitionsError {}

impl ListFlowDefinitionsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFlowDefinitionsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListFlowDefinitionsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListFlowDefinitionsError {}
/// Errors returned by ListHumanTaskUis
#[derive(Debug, PartialEq)]
pub enum ListHumanTaskUisError {}

impl ListHumanTaskUisError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListHumanTaskUisError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListHumanTaskUisError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListHumanTaskUisError {}
/// Errors returned by ListHyperParameterTuningJobs
#[derive(Debug, PartialEq)]
pub enum ListHyperParameterTuningJobsError {}

impl ListHyperParameterTuningJobsError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<ListHyperParameterTuningJobsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListHyperParameterTuningJobsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListHyperParameterTuningJobsError {}
/// Errors returned by ListImageVersions
#[derive(Debug, PartialEq)]
pub enum ListImageVersionsError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl ListImageVersionsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListImageVersionsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(ListImageVersionsError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListImageVersionsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ListImageVersionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for ListImageVersionsError {}
/// Errors returned by ListImages
#[derive(Debug, PartialEq)]
pub enum ListImagesError {}

impl ListImagesError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListImagesError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListImagesError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListImagesError {}
/// Errors returned by ListLabelingJobs
#[derive(Debug, PartialEq)]
pub enum ListLabelingJobsError {}

impl ListLabelingJobsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLabelingJobsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListLabelingJobsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListLabelingJobsError {}
/// Errors returned by ListLabelingJobsForWorkteam
#[derive(Debug, PartialEq)]
pub enum ListLabelingJobsForWorkteamError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl ListLabelingJobsForWorkteamError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<ListLabelingJobsForWorkteamError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(
                        ListLabelingJobsForWorkteamError::ResourceNotFound(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListLabelingJobsForWorkteamError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ListLabelingJobsForWorkteamError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for ListLabelingJobsForWorkteamError {}
/// Errors returned by ListModelBiasJobDefinitions
#[derive(Debug, PartialEq)]
pub enum ListModelBiasJobDefinitionsError {}

impl ListModelBiasJobDefinitionsError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<ListModelBiasJobDefinitionsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListModelBiasJobDefinitionsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListModelBiasJobDefinitionsError {}
/// Errors returned by ListModelExplainabilityJobDefinitions
#[derive(Debug, PartialEq)]
pub enum ListModelExplainabilityJobDefinitionsError {}

impl ListModelExplainabilityJobDefinitionsError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<ListModelExplainabilityJobDefinitionsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListModelExplainabilityJobDefinitionsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListModelExplainabilityJobDefinitionsError {}
/// Errors returned by ListModelPackageGroups
#[derive(Debug, PartialEq)]
pub enum ListModelPackageGroupsError {}

impl ListModelPackageGroupsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListModelPackageGroupsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListModelPackageGroupsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListModelPackageGroupsError {}
/// Errors returned by ListModelPackages
#[derive(Debug, PartialEq)]
pub enum ListModelPackagesError {}

impl ListModelPackagesError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListModelPackagesError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListModelPackagesError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListModelPackagesError {}
/// Errors returned by ListModelQualityJobDefinitions
#[derive(Debug, PartialEq)]
pub enum ListModelQualityJobDefinitionsError {}

impl ListModelQualityJobDefinitionsError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<ListModelQualityJobDefinitionsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListModelQualityJobDefinitionsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListModelQualityJobDefinitionsError {}
/// Errors returned by ListModels
#[derive(Debug, PartialEq)]
pub enum ListModelsError {}

impl ListModelsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListModelsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListModelsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListModelsError {}
/// Errors returned by ListMonitoringExecutions
#[derive(Debug, PartialEq)]
pub enum ListMonitoringExecutionsError {}

impl ListMonitoringExecutionsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListMonitoringExecutionsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListMonitoringExecutionsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListMonitoringExecutionsError {}
/// Errors returned by ListMonitoringSchedules
#[derive(Debug, PartialEq)]
pub enum ListMonitoringSchedulesError {}

impl ListMonitoringSchedulesError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListMonitoringSchedulesError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListMonitoringSchedulesError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListMonitoringSchedulesError {}
/// Errors returned by ListNotebookInstanceLifecycleConfigs
#[derive(Debug, PartialEq)]
pub enum ListNotebookInstanceLifecycleConfigsError {}

impl ListNotebookInstanceLifecycleConfigsError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<ListNotebookInstanceLifecycleConfigsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListNotebookInstanceLifecycleConfigsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListNotebookInstanceLifecycleConfigsError {}
/// Errors returned by ListNotebookInstances
#[derive(Debug, PartialEq)]
pub enum ListNotebookInstancesError {}

impl ListNotebookInstancesError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListNotebookInstancesError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListNotebookInstancesError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListNotebookInstancesError {}
/// Errors returned by ListPipelineExecutionSteps
#[derive(Debug, PartialEq)]
pub enum ListPipelineExecutionStepsError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl ListPipelineExecutionStepsError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<ListPipelineExecutionStepsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(ListPipelineExecutionStepsError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListPipelineExecutionStepsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ListPipelineExecutionStepsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for ListPipelineExecutionStepsError {}
/// Errors returned by ListPipelineExecutions
#[derive(Debug, PartialEq)]
pub enum ListPipelineExecutionsError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl ListPipelineExecutionsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPipelineExecutionsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(ListPipelineExecutionsError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListPipelineExecutionsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ListPipelineExecutionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for ListPipelineExecutionsError {}
/// Errors returned by ListPipelineParametersForExecution
#[derive(Debug, PartialEq)]
pub enum ListPipelineParametersForExecutionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl ListPipelineParametersForExecutionError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<ListPipelineParametersForExecutionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(
                        ListPipelineParametersForExecutionError::ResourceNotFound(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListPipelineParametersForExecutionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ListPipelineParametersForExecutionError::ResourceNotFound(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for ListPipelineParametersForExecutionError {}
/// Errors returned by ListPipelines
#[derive(Debug, PartialEq)]
pub enum ListPipelinesError {}

impl ListPipelinesError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPipelinesError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListPipelinesError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListPipelinesError {}
/// Errors returned by ListProcessingJobs
#[derive(Debug, PartialEq)]
pub enum ListProcessingJobsError {}

impl ListProcessingJobsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListProcessingJobsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListProcessingJobsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListProcessingJobsError {}
/// Errors returned by ListProjects
#[derive(Debug, PartialEq)]
pub enum ListProjectsError {}

impl ListProjectsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListProjectsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListProjectsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListProjectsError {}
/// Errors returned by ListSubscribedWorkteams
#[derive(Debug, PartialEq)]
pub enum ListSubscribedWorkteamsError {}

impl ListSubscribedWorkteamsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSubscribedWorkteamsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListSubscribedWorkteamsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListSubscribedWorkteamsError {}
/// Errors returned by ListTags
#[derive(Debug, PartialEq)]
pub enum ListTagsError {}

impl ListTagsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListTagsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListTagsError {}
/// Errors returned by ListTrainingJobs
#[derive(Debug, PartialEq)]
pub enum ListTrainingJobsError {}

impl ListTrainingJobsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTrainingJobsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListTrainingJobsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListTrainingJobsError {}
/// Errors returned by ListTrainingJobsForHyperParameterTuningJob
#[derive(Debug, PartialEq)]
pub enum ListTrainingJobsForHyperParameterTuningJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl ListTrainingJobsForHyperParameterTuningJobError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<ListTrainingJobsForHyperParameterTuningJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(
                        ListTrainingJobsForHyperParameterTuningJobError::ResourceNotFound(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListTrainingJobsForHyperParameterTuningJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ListTrainingJobsForHyperParameterTuningJobError::ResourceNotFound(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for ListTrainingJobsForHyperParameterTuningJobError {}
/// Errors returned by ListTransformJobs
#[derive(Debug, PartialEq)]
pub enum ListTransformJobsError {}

impl ListTransformJobsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTransformJobsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListTransformJobsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListTransformJobsError {}
/// Errors returned by ListTrialComponents
#[derive(Debug, PartialEq)]
pub enum ListTrialComponentsError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl ListTrialComponentsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTrialComponentsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(ListTrialComponentsError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListTrialComponentsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ListTrialComponentsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for ListTrialComponentsError {}
/// Errors returned by ListTrials
#[derive(Debug, PartialEq)]
pub enum ListTrialsError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl ListTrialsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTrialsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(ListTrialsError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListTrialsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ListTrialsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for ListTrialsError {}
/// Errors returned by ListUserProfiles
#[derive(Debug, PartialEq)]
pub enum ListUserProfilesError {}

impl ListUserProfilesError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListUserProfilesError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListUserProfilesError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListUserProfilesError {}
/// Errors returned by ListWorkforces
#[derive(Debug, PartialEq)]
pub enum ListWorkforcesError {}

impl ListWorkforcesError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListWorkforcesError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListWorkforcesError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListWorkforcesError {}
/// Errors returned by ListWorkteams
#[derive(Debug, PartialEq)]
pub enum ListWorkteamsError {}

impl ListWorkteamsError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListWorkteamsError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for ListWorkteamsError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for ListWorkteamsError {}
/// Errors returned by PutModelPackageGroupPolicy
#[derive(Debug, PartialEq)]
pub enum PutModelPackageGroupPolicyError {}

impl PutModelPackageGroupPolicyError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<PutModelPackageGroupPolicyError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for PutModelPackageGroupPolicyError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for PutModelPackageGroupPolicyError {}
/// Errors returned by RegisterDevices
#[derive(Debug, PartialEq)]
pub enum RegisterDevicesError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl RegisterDevicesError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RegisterDevicesError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(RegisterDevicesError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for RegisterDevicesError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            RegisterDevicesError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for RegisterDevicesError {}
/// Errors returned by RenderUiTemplate
#[derive(Debug, PartialEq)]
pub enum RenderUiTemplateError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl RenderUiTemplateError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RenderUiTemplateError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(RenderUiTemplateError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for RenderUiTemplateError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            RenderUiTemplateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for RenderUiTemplateError {}
/// Errors returned by Search
#[derive(Debug, PartialEq)]
pub enum SearchError {}

impl SearchError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SearchError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for SearchError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for SearchError {}
/// Errors returned by StartMonitoringSchedule
#[derive(Debug, PartialEq)]
pub enum StartMonitoringScheduleError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl StartMonitoringScheduleError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartMonitoringScheduleError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(StartMonitoringScheduleError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for StartMonitoringScheduleError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            StartMonitoringScheduleError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for StartMonitoringScheduleError {}
/// Errors returned by StartNotebookInstance
#[derive(Debug, PartialEq)]
pub enum StartNotebookInstanceError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl StartNotebookInstanceError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartNotebookInstanceError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(StartNotebookInstanceError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for StartNotebookInstanceError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            StartNotebookInstanceError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for StartNotebookInstanceError {}
/// Errors returned by StartPipelineExecution
#[derive(Debug, PartialEq)]
pub enum StartPipelineExecutionError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl StartPipelineExecutionError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartPipelineExecutionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        StartPipelineExecutionError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(StartPipelineExecutionError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for StartPipelineExecutionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            StartPipelineExecutionError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
            StartPipelineExecutionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for StartPipelineExecutionError {}
/// Errors returned by StopAutoMLJob
#[derive(Debug, PartialEq)]
pub enum StopAutoMLJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl StopAutoMLJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopAutoMLJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(StopAutoMLJobError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for StopAutoMLJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            StopAutoMLJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for StopAutoMLJobError {}
/// Errors returned by StopCompilationJob
#[derive(Debug, PartialEq)]
pub enum StopCompilationJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl StopCompilationJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopCompilationJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(StopCompilationJobError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for StopCompilationJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            StopCompilationJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for StopCompilationJobError {}
/// Errors returned by StopEdgePackagingJob
#[derive(Debug, PartialEq)]
pub enum StopEdgePackagingJobError {}

impl StopEdgePackagingJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopEdgePackagingJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for StopEdgePackagingJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for StopEdgePackagingJobError {}
/// Errors returned by StopHyperParameterTuningJob
#[derive(Debug, PartialEq)]
pub enum StopHyperParameterTuningJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl StopHyperParameterTuningJobError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<StopHyperParameterTuningJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(
                        StopHyperParameterTuningJobError::ResourceNotFound(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for StopHyperParameterTuningJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            StopHyperParameterTuningJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for StopHyperParameterTuningJobError {}
/// Errors returned by StopLabelingJob
#[derive(Debug, PartialEq)]
pub enum StopLabelingJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl StopLabelingJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopLabelingJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(StopLabelingJobError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for StopLabelingJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            StopLabelingJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for StopLabelingJobError {}
/// Errors returned by StopMonitoringSchedule
#[derive(Debug, PartialEq)]
pub enum StopMonitoringScheduleError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl StopMonitoringScheduleError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopMonitoringScheduleError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(StopMonitoringScheduleError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for StopMonitoringScheduleError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            StopMonitoringScheduleError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for StopMonitoringScheduleError {}
/// Errors returned by StopNotebookInstance
#[derive(Debug, PartialEq)]
pub enum StopNotebookInstanceError {}

impl StopNotebookInstanceError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopNotebookInstanceError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for StopNotebookInstanceError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for StopNotebookInstanceError {}
/// Errors returned by StopPipelineExecution
#[derive(Debug, PartialEq)]
pub enum StopPipelineExecutionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl StopPipelineExecutionError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopPipelineExecutionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(StopPipelineExecutionError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for StopPipelineExecutionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            StopPipelineExecutionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for StopPipelineExecutionError {}
/// Errors returned by StopProcessingJob
#[derive(Debug, PartialEq)]
pub enum StopProcessingJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl StopProcessingJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopProcessingJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(StopProcessingJobError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for StopProcessingJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            StopProcessingJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for StopProcessingJobError {}
/// Errors returned by StopTrainingJob
#[derive(Debug, PartialEq)]
pub enum StopTrainingJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl StopTrainingJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopTrainingJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(StopTrainingJobError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for StopTrainingJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            StopTrainingJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for StopTrainingJobError {}
/// Errors returned by StopTransformJob
#[derive(Debug, PartialEq)]
pub enum StopTransformJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl StopTransformJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopTransformJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(StopTransformJobError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for StopTransformJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            StopTransformJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for StopTransformJobError {}
/// Errors returned by UpdateAction
#[derive(Debug, PartialEq)]
pub enum UpdateActionError {
    /// <p>There was a conflict when you attempted to modify an experiment, trial, or trial component.</p>
    Conflict(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl UpdateActionError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateActionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ConflictException" => {
                    return RusotoError::Service(UpdateActionError::Conflict(err.msg))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(UpdateActionError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateActionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateActionError::Conflict(ref cause) => write!(f, "{}", cause),
            UpdateActionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateActionError {}
/// Errors returned by UpdateAppImageConfig
#[derive(Debug, PartialEq)]
pub enum UpdateAppImageConfigError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl UpdateAppImageConfigError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateAppImageConfigError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(UpdateAppImageConfigError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateAppImageConfigError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateAppImageConfigError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateAppImageConfigError {}
/// Errors returned by UpdateArtifact
#[derive(Debug, PartialEq)]
pub enum UpdateArtifactError {
    /// <p>There was a conflict when you attempted to modify an experiment, trial, or trial component.</p>
    Conflict(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl UpdateArtifactError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateArtifactError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ConflictException" => {
                    return RusotoError::Service(UpdateArtifactError::Conflict(err.msg))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(UpdateArtifactError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateArtifactError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateArtifactError::Conflict(ref cause) => write!(f, "{}", cause),
            UpdateArtifactError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateArtifactError {}
/// Errors returned by UpdateCodeRepository
#[derive(Debug, PartialEq)]
pub enum UpdateCodeRepositoryError {}

impl UpdateCodeRepositoryError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateCodeRepositoryError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateCodeRepositoryError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for UpdateCodeRepositoryError {}
/// Errors returned by UpdateContext
#[derive(Debug, PartialEq)]
pub enum UpdateContextError {
    /// <p>There was a conflict when you attempted to modify an experiment, trial, or trial component.</p>
    Conflict(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl UpdateContextError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateContextError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ConflictException" => {
                    return RusotoError::Service(UpdateContextError::Conflict(err.msg))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(UpdateContextError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateContextError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateContextError::Conflict(ref cause) => write!(f, "{}", cause),
            UpdateContextError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateContextError {}
/// Errors returned by UpdateDeviceFleet
#[derive(Debug, PartialEq)]
pub enum UpdateDeviceFleetError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
}

impl UpdateDeviceFleetError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDeviceFleetError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(UpdateDeviceFleetError::ResourceInUse(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateDeviceFleetError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateDeviceFleetError::ResourceInUse(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateDeviceFleetError {}
/// Errors returned by UpdateDevices
#[derive(Debug, PartialEq)]
pub enum UpdateDevicesError {}

impl UpdateDevicesError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDevicesError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateDevicesError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for UpdateDevicesError {}
/// Errors returned by UpdateDomain
#[derive(Debug, PartialEq)]
pub enum UpdateDomainError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl UpdateDomainError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDomainError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(UpdateDomainError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(UpdateDomainError::ResourceLimitExceeded(err.msg))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(UpdateDomainError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateDomainError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateDomainError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            UpdateDomainError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
            UpdateDomainError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateDomainError {}
/// Errors returned by UpdateEndpoint
#[derive(Debug, PartialEq)]
pub enum UpdateEndpointError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl UpdateEndpointError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateEndpointError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(UpdateEndpointError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateEndpointError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateEndpointError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateEndpointError {}
/// Errors returned by UpdateEndpointWeightsAndCapacities
#[derive(Debug, PartialEq)]
pub enum UpdateEndpointWeightsAndCapacitiesError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl UpdateEndpointWeightsAndCapacitiesError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<UpdateEndpointWeightsAndCapacitiesError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        UpdateEndpointWeightsAndCapacitiesError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateEndpointWeightsAndCapacitiesError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateEndpointWeightsAndCapacitiesError::ResourceLimitExceeded(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for UpdateEndpointWeightsAndCapacitiesError {}
/// Errors returned by UpdateExperiment
#[derive(Debug, PartialEq)]
pub enum UpdateExperimentError {
    /// <p>There was a conflict when you attempted to modify an experiment, trial, or trial component.</p>
    Conflict(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl UpdateExperimentError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateExperimentError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ConflictException" => {
                    return RusotoError::Service(UpdateExperimentError::Conflict(err.msg))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(UpdateExperimentError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateExperimentError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateExperimentError::Conflict(ref cause) => write!(f, "{}", cause),
            UpdateExperimentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateExperimentError {}
/// Errors returned by UpdateImage
#[derive(Debug, PartialEq)]
pub enum UpdateImageError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl UpdateImageError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateImageError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(UpdateImageError::ResourceInUse(err.msg))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(UpdateImageError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateImageError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateImageError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            UpdateImageError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateImageError {}
/// Errors returned by UpdateModelPackage
#[derive(Debug, PartialEq)]
pub enum UpdateModelPackageError {}

impl UpdateModelPackageError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateModelPackageError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateModelPackageError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for UpdateModelPackageError {}
/// Errors returned by UpdateMonitoringSchedule
#[derive(Debug, PartialEq)]
pub enum UpdateMonitoringScheduleError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl UpdateMonitoringScheduleError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateMonitoringScheduleError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        UpdateMonitoringScheduleError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(UpdateMonitoringScheduleError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateMonitoringScheduleError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateMonitoringScheduleError::ResourceLimitExceeded(ref cause) => {
                write!(f, "{}", cause)
            }
            UpdateMonitoringScheduleError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateMonitoringScheduleError {}
/// Errors returned by UpdateNotebookInstance
#[derive(Debug, PartialEq)]
pub enum UpdateNotebookInstanceError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl UpdateNotebookInstanceError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateNotebookInstanceError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        UpdateNotebookInstanceError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateNotebookInstanceError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateNotebookInstanceError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateNotebookInstanceError {}
/// Errors returned by UpdateNotebookInstanceLifecycleConfig
#[derive(Debug, PartialEq)]
pub enum UpdateNotebookInstanceLifecycleConfigError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl UpdateNotebookInstanceLifecycleConfigError {
    pub fn from_response(
        res: BufferedHttpResponse,
    ) -> RusotoError<UpdateNotebookInstanceLifecycleConfigError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(
                        UpdateNotebookInstanceLifecycleConfigError::ResourceLimitExceeded(err.msg),
                    )
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateNotebookInstanceLifecycleConfigError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateNotebookInstanceLifecycleConfigError::ResourceLimitExceeded(ref cause) => {
                write!(f, "{}", cause)
            }
        }
    }
}
impl Error for UpdateNotebookInstanceLifecycleConfigError {}
/// Errors returned by UpdatePipeline
#[derive(Debug, PartialEq)]
pub enum UpdatePipelineError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl UpdatePipelineError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdatePipelineError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(UpdatePipelineError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdatePipelineError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdatePipelineError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdatePipelineError {}
/// Errors returned by UpdatePipelineExecution
#[derive(Debug, PartialEq)]
pub enum UpdatePipelineExecutionError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl UpdatePipelineExecutionError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdatePipelineExecutionError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(UpdatePipelineExecutionError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdatePipelineExecutionError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdatePipelineExecutionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdatePipelineExecutionError {}
/// Errors returned by UpdateTrainingJob
#[derive(Debug, PartialEq)]
pub enum UpdateTrainingJobError {
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl UpdateTrainingJobError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateTrainingJobError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceNotFound" => {
                    return RusotoError::Service(UpdateTrainingJobError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateTrainingJobError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateTrainingJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateTrainingJobError {}
/// Errors returned by UpdateTrial
#[derive(Debug, PartialEq)]
pub enum UpdateTrialError {
    /// <p>There was a conflict when you attempted to modify an experiment, trial, or trial component.</p>
    Conflict(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl UpdateTrialError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateTrialError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ConflictException" => {
                    return RusotoError::Service(UpdateTrialError::Conflict(err.msg))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(UpdateTrialError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateTrialError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateTrialError::Conflict(ref cause) => write!(f, "{}", cause),
            UpdateTrialError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateTrialError {}
/// Errors returned by UpdateTrialComponent
#[derive(Debug, PartialEq)]
pub enum UpdateTrialComponentError {
    /// <p>There was a conflict when you attempted to modify an experiment, trial, or trial component.</p>
    Conflict(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl UpdateTrialComponentError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateTrialComponentError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ConflictException" => {
                    return RusotoError::Service(UpdateTrialComponentError::Conflict(err.msg))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(UpdateTrialComponentError::ResourceNotFound(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateTrialComponentError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateTrialComponentError::Conflict(ref cause) => write!(f, "{}", cause),
            UpdateTrialComponentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateTrialComponentError {}
/// Errors returned by UpdateUserProfile
#[derive(Debug, PartialEq)]
pub enum UpdateUserProfileError {
    /// <p>Resource being accessed is in use.</p>
    ResourceInUse(String),
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
    /// <p>Resource being access is not found.</p>
    ResourceNotFound(String),
}

impl UpdateUserProfileError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateUserProfileError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceInUse" => {
                    return RusotoError::Service(UpdateUserProfileError::ResourceInUse(err.msg))
                }
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(UpdateUserProfileError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ResourceNotFound" => {
                    return RusotoError::Service(UpdateUserProfileError::ResourceNotFound(err.msg))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateUserProfileError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateUserProfileError::ResourceInUse(ref cause) => write!(f, "{}", cause),
            UpdateUserProfileError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
            UpdateUserProfileError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateUserProfileError {}
/// Errors returned by UpdateWorkforce
#[derive(Debug, PartialEq)]
pub enum UpdateWorkforceError {}

impl UpdateWorkforceError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateWorkforceError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateWorkforceError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
impl Error for UpdateWorkforceError {}
/// Errors returned by UpdateWorkteam
#[derive(Debug, PartialEq)]
pub enum UpdateWorkteamError {
    /// <p> You have exceeded an Amazon SageMaker resource limit. For example, you might have too many training jobs created. </p>
    ResourceLimitExceeded(String),
}

impl UpdateWorkteamError {
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateWorkteamError> {
        if let Some(err) = proto::json::Error::parse(&res) {
            match err.typ.as_str() {
                "ResourceLimitExceeded" => {
                    return RusotoError::Service(UpdateWorkteamError::ResourceLimitExceeded(
                        err.msg,
                    ))
                }
                "ValidationException" => return RusotoError::Validation(err.msg),
                _ => {}
            }
        }
        RusotoError::Unknown(res)
    }
}
impl fmt::Display for UpdateWorkteamError {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UpdateWorkteamError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
        }
    }
}
impl Error for UpdateWorkteamError {}
/// Trait representing the capabilities of the SageMaker API. SageMaker clients implement this trait.
#[async_trait]
pub trait SageMaker {
    /// <p>Creates an <i>association</i> between the source and the destination. A source can be associated with multiple destinations, and a destination can be associated with multiple sources. An association is a lineage tracking entity. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/lineage-tracking.html">Amazon SageMaker ML Lineage Tracking</a>.</p>
    async fn add_association(
        &self,
        input: AddAssociationRequest,
    ) -> Result<AddAssociationResponse, RusotoError<AddAssociationError>>;

    /// <p><p>Adds or overwrites one or more tags for the specified Amazon SageMaker resource. You can add tags to notebook instances, training jobs, hyperparameter tuning jobs, batch transform jobs, models, labeling jobs, work teams, endpoint configurations, and endpoints.</p> <p>Each tag consists of a key and an optional value. Tag keys must be unique per resource. For more information about tags, see For more information, see <a href="https://aws.amazon.com/answers/account-management/aws-tagging-strategies/">AWS Tagging Strategies</a>.</p> <note> <p>Tags that you add to a hyperparameter tuning job by calling this API are also added to any training jobs that the hyperparameter tuning job launches after you call this API, but not to training jobs that the hyperparameter tuning job launched before you called this API. To make sure that the tags associated with a hyperparameter tuning job are also added to all training jobs that the hyperparameter tuning job launches, add the tags when you first create the tuning job by specifying them in the <code>Tags</code> parameter of <a>CreateHyperParameterTuningJob</a> </p> </note></p>
    async fn add_tags(
        &self,
        input: AddTagsInput,
    ) -> Result<AddTagsOutput, RusotoError<AddTagsError>>;

    /// <p>Associates a trial component with a trial. A trial component can be associated with multiple trials. To disassociate a trial component from a trial, call the <a>DisassociateTrialComponent</a> API.</p>
    async fn associate_trial_component(
        &self,
        input: AssociateTrialComponentRequest,
    ) -> Result<AssociateTrialComponentResponse, RusotoError<AssociateTrialComponentError>>;

    /// <p>Creates an <i>action</i>. An action is a lineage tracking entity that represents an action or activity. For example, a model deployment or an HPO job. Generally, an action involves at least one input or output artifact. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/lineage-tracking.html">Amazon SageMaker ML Lineage Tracking</a>.</p>
    async fn create_action(
        &self,
        input: CreateActionRequest,
    ) -> Result<CreateActionResponse, RusotoError<CreateActionError>>;

    /// <p>Create a machine learning algorithm that you can use in Amazon SageMaker and list in the AWS Marketplace.</p>
    async fn create_algorithm(
        &self,
        input: CreateAlgorithmInput,
    ) -> Result<CreateAlgorithmOutput, RusotoError<CreateAlgorithmError>>;

    /// <p>Creates a running App for the specified UserProfile. Supported Apps are JupyterServer and KernelGateway. This operation is automatically invoked by Amazon SageMaker Studio upon access to the associated Domain, and when new kernel configurations are selected by the user. A user may have multiple Apps active simultaneously.</p>
    async fn create_app(
        &self,
        input: CreateAppRequest,
    ) -> Result<CreateAppResponse, RusotoError<CreateAppError>>;

    /// <p>Creates a configuration for running a SageMaker image as a KernelGateway app. The configuration specifies the Amazon Elastic File System (EFS) storage volume on the image, and a list of the kernels in the image.</p>
    async fn create_app_image_config(
        &self,
        input: CreateAppImageConfigRequest,
    ) -> Result<CreateAppImageConfigResponse, RusotoError<CreateAppImageConfigError>>;

    /// <p>Creates an <i>artifact</i>. An artifact is a lineage tracking entity that represents a URI addressable object or data. Some examples are the S3 URI of a dataset and the ECR registry path of an image. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/lineage-tracking.html">Amazon SageMaker ML Lineage Tracking</a>.</p>
    async fn create_artifact(
        &self,
        input: CreateArtifactRequest,
    ) -> Result<CreateArtifactResponse, RusotoError<CreateArtifactError>>;

    /// <p>Creates an Autopilot job.</p> <p>Find the best performing model after you run an Autopilot job by calling . Deploy that model by following the steps described in <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/ex1-deploy-model.html">Step 6.1: Deploy the Model to Amazon SageMaker Hosting Services</a>.</p> <p>For information about how to use Autopilot, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development.html"> Automate Model Development with Amazon SageMaker Autopilot</a>.</p>
    async fn create_auto_ml_job(
        &self,
        input: CreateAutoMLJobRequest,
    ) -> Result<CreateAutoMLJobResponse, RusotoError<CreateAutoMLJobError>>;

    /// <p>Creates a Git repository as a resource in your Amazon SageMaker account. You can associate the repository with notebook instances so that you can use Git source control for the notebooks you create. The Git repository is a resource in your Amazon SageMaker account, so it can be associated with more than one notebook instance, and it persists independently from the lifecycle of any notebook instances it is associated with.</p> <p>The repository can be hosted either in <a href="https://docs.aws.amazon.com/codecommit/latest/userguide/welcome.html">AWS CodeCommit</a> or in any other Git repository.</p>
    async fn create_code_repository(
        &self,
        input: CreateCodeRepositoryInput,
    ) -> Result<CreateCodeRepositoryOutput, RusotoError<CreateCodeRepositoryError>>;

    /// <p>Starts a model compilation job. After the model has been compiled, Amazon SageMaker saves the resulting model artifacts to an Amazon Simple Storage Service (Amazon S3) bucket that you specify. </p> <p>If you choose to host your model using Amazon SageMaker hosting services, you can use the resulting model artifacts as part of the model. You can also use the artifacts with AWS IoT Greengrass. In that case, deploy them as an ML resource.</p> <p>In the request body, you provide the following:</p> <ul> <li> <p>A name for the compilation job</p> </li> <li> <p> Information about the input model artifacts </p> </li> <li> <p>The output location for the compiled model and the device (target) that the model runs on </p> </li> <li> <p>The Amazon Resource Name (ARN) of the IAM role that Amazon SageMaker assumes to perform the model compilation job. </p> </li> </ul> <p>You can also provide a <code>Tag</code> to track the model compilation job's resource use and costs. The response body contains the <code>CompilationJobArn</code> for the compiled job.</p> <p>To stop a model compilation job, use <a>StopCompilationJob</a>. To get information about a particular model compilation job, use <a>DescribeCompilationJob</a>. To get information about multiple model compilation jobs, use <a>ListCompilationJobs</a>.</p>
    async fn create_compilation_job(
        &self,
        input: CreateCompilationJobRequest,
    ) -> Result<CreateCompilationJobResponse, RusotoError<CreateCompilationJobError>>;

    /// <p>Creates a <i>context</i>. A context is a lineage tracking entity that represents a logical grouping of other tracking or experiment entities. Some examples are an endpoint and a model package. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/lineage-tracking.html">Amazon SageMaker ML Lineage Tracking</a>.</p>
    async fn create_context(
        &self,
        input: CreateContextRequest,
    ) -> Result<CreateContextResponse, RusotoError<CreateContextError>>;

    /// <p>Creates a definition for a job that monitors data quality and drift. For information about model monitor, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor.html">Amazon SageMaker Model Monitor</a>.</p>
    async fn create_data_quality_job_definition(
        &self,
        input: CreateDataQualityJobDefinitionRequest,
    ) -> Result<
        CreateDataQualityJobDefinitionResponse,
        RusotoError<CreateDataQualityJobDefinitionError>,
    >;

    /// <p>Creates a device fleet.</p>
    async fn create_device_fleet(
        &self,
        input: CreateDeviceFleetRequest,
    ) -> Result<(), RusotoError<CreateDeviceFleetError>>;

    /// <p>Creates a <code>Domain</code> used by Amazon SageMaker Studio. A domain consists of an associated Amazon Elastic File System (EFS) volume, a list of authorized users, and a variety of security, application, policy, and Amazon Virtual Private Cloud (VPC) configurations. An AWS account is limited to one domain per region. Users within a domain can share notebook files and other artifacts with each other.</p> <p> <b>EFS storage</b> </p> <p>When a domain is created, an EFS volume is created for use by all of the users within the domain. Each user receives a private home directory within the EFS volume for notebooks, Git repositories, and data files.</p> <p>SageMaker uses the AWS Key Management Service (AWS KMS) to encrypt the EFS volume attached to the domain with an AWS managed customer master key (CMK) by default. For more control, you can specify a customer managed CMK. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/encryption-at-rest.html">Protect Data at Rest Using Encryption</a>.</p> <p> <b>VPC configuration</b> </p> <p>All SageMaker Studio traffic between the domain and the EFS volume is through the specified VPC and subnets. For other Studio traffic, you can specify the <code>AppNetworkAccessType</code> parameter. <code>AppNetworkAccessType</code> corresponds to the network access type that you choose when you onboard to Studio. The following options are available:</p> <ul> <li> <p> <code>PublicInternetOnly</code> - Non-EFS traffic goes through a VPC managed by Amazon SageMaker, which allows internet access. This is the default value.</p> </li> <li> <p> <code>VpcOnly</code> - All Studio traffic is through the specified VPC and subnets. Internet access is disabled by default. To allow internet access, you must specify a NAT gateway.</p> <p>When internet access is disabled, you won't be able to run a Studio notebook or to train or host models unless your VPC has an interface endpoint to the SageMaker API and runtime or a NAT gateway and your security groups allow outbound connections.</p> </li> </ul> <p>For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/studio-notebooks-and-internet-access.html">Connect SageMaker Studio Notebooks to Resources in a VPC</a>.</p>
    async fn create_domain(
        &self,
        input: CreateDomainRequest,
    ) -> Result<CreateDomainResponse, RusotoError<CreateDomainError>>;

    /// <p>Starts a SageMaker Edge Manager model packaging job. Edge Manager will use the model artifacts from the Amazon Simple Storage Service bucket that you specify. After the model has been packaged, Amazon SageMaker saves the resulting artifacts to an S3 bucket that you specify.</p>
    async fn create_edge_packaging_job(
        &self,
        input: CreateEdgePackagingJobRequest,
    ) -> Result<(), RusotoError<CreateEdgePackagingJobError>>;

    /// <p><p>Creates an endpoint using the endpoint configuration specified in the request. Amazon SageMaker uses the endpoint to provision resources and deploy models. You create the endpoint configuration with the <a>CreateEndpointConfig</a> API. </p> <p> Use this API to deploy models using Amazon SageMaker hosting services. </p> <p>For an example that calls this method when deploying a model to Amazon SageMaker hosting services, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/ex1-deploy-model.html#ex1-deploy-model-boto">Deploy the Model to Amazon SageMaker Hosting Services (AWS SDK for Python (Boto 3)).</a> </p> <note> <p> You must not delete an <code>EndpointConfig</code> that is in use by an endpoint that is live or while the <code>UpdateEndpoint</code> or <code>CreateEndpoint</code> operations are being performed on the endpoint. To update an endpoint, you must create a new <code>EndpointConfig</code>.</p> </note> <p>The endpoint name must be unique within an AWS Region in your AWS account. </p> <p>When it receives the request, Amazon SageMaker creates the endpoint, launches the resources (ML compute instances), and deploys the model(s) on them. </p> <note> <p>When you call <a>CreateEndpoint</a>, a load call is made to DynamoDB to verify that your endpoint configuration exists. When you read data from a DynamoDB table supporting <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadConsistency.html"> <code>Eventually Consistent Reads</code> </a>, the response might not reflect the results of a recently completed write operation. The response might include some stale data. If the dependent entities are not yet in DynamoDB, this causes a validation error. If you repeat your read request after a short time, the response should return the latest data. So retry logic is recommended to handle these possible issues. We also recommend that customers call <a>DescribeEndpointConfig</a> before calling <a>CreateEndpoint</a> to minimize the potential impact of a DynamoDB eventually consistent read.</p> </note> <p>When Amazon SageMaker receives the request, it sets the endpoint status to <code>Creating</code>. After it creates the endpoint, it sets the status to <code>InService</code>. Amazon SageMaker can then process incoming requests for inferences. To check the status of an endpoint, use the <a>DescribeEndpoint</a> API.</p> <p>If any of the models hosted at this endpoint get model data from an Amazon S3 location, Amazon SageMaker uses AWS Security Token Service to download model artifacts from the S3 path you provided. AWS STS is activated in your IAM user account by default. If you previously deactivated AWS STS for a region, you need to reactivate AWS STS for that region. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html">Activating and Deactivating AWS STS in an AWS Region</a> in the <i>AWS Identity and Access Management User Guide</i>.</p> <note> <p> To add the IAM role policies for using this API operation, go to the <a href="https://console.aws.amazon.com/iam/">IAM console</a>, and choose Roles in the left navigation pane. Search the IAM role that you want to grant access to use the <a>CreateEndpoint</a> and <a>CreateEndpointConfig</a> API operations, add the following policies to the role. </p> <ul> <li> <p>Option 1: For a full Amazon SageMaker access, search and attach the <code>AmazonSageMakerFullAccess</code> policy.</p> </li> <li> <p>Option 2: For granting a limited access to an IAM role, paste the following Action elements manually into the JSON file of the IAM role: </p> <p> <code>&quot;Action&quot;: [&quot;sagemaker:CreateEndpoint&quot;, &quot;sagemaker:CreateEndpointConfig&quot;]</code> </p> <p> <code>&quot;Resource&quot;: [</code> </p> <p> <code>&quot;arn:aws:sagemaker:region:account-id:endpoint/endpointName&quot;</code> </p> <p> <code>&quot;arn:aws:sagemaker:region:account-id:endpoint-config/endpointConfigName&quot;</code> </p> <p> <code>]</code> </p> <p>For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/api-permissions-reference.html">Amazon SageMaker API Permissions: Actions, Permissions, and Resources Reference</a>.</p> </li> </ul> </note></p>
    async fn create_endpoint(
        &self,
        input: CreateEndpointInput,
    ) -> Result<CreateEndpointOutput, RusotoError<CreateEndpointError>>;

    /// <p><p>Creates an endpoint configuration that Amazon SageMaker hosting services uses to deploy models. In the configuration, you identify one or more models, created using the <code>CreateModel</code> API, to deploy and the resources that you want Amazon SageMaker to provision. Then you call the <a>CreateEndpoint</a> API.</p> <note> <p> Use this API if you want to use Amazon SageMaker hosting services to deploy models into production. </p> </note> <p>In the request, you define a <code>ProductionVariant</code>, for each model that you want to deploy. Each <code>ProductionVariant</code> parameter also describes the resources that you want Amazon SageMaker to provision. This includes the number and type of ML compute instances to deploy. </p> <p>If you are hosting multiple models, you also assign a <code>VariantWeight</code> to specify how much traffic you want to allocate to each model. For example, suppose that you want to host two models, A and B, and you assign traffic weight 2 for model A and 1 for model B. Amazon SageMaker distributes two-thirds of the traffic to Model A, and one-third to model B. </p> <p>For an example that calls this method when deploying a model to Amazon SageMaker hosting services, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/ex1-deploy-model.html#ex1-deploy-model-boto">Deploy the Model to Amazon SageMaker Hosting Services (AWS SDK for Python (Boto 3)).</a> </p> <note> <p>When you call <a>CreateEndpoint</a>, a load call is made to DynamoDB to verify that your endpoint configuration exists. When you read data from a DynamoDB table supporting <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadConsistency.html"> <code>Eventually Consistent Reads</code> </a>, the response might not reflect the results of a recently completed write operation. The response might include some stale data. If the dependent entities are not yet in DynamoDB, this causes a validation error. If you repeat your read request after a short time, the response should return the latest data. So retry logic is recommended to handle these possible issues. We also recommend that customers call <a>DescribeEndpointConfig</a> before calling <a>CreateEndpoint</a> to minimize the potential impact of a DynamoDB eventually consistent read.</p> </note></p>
    async fn create_endpoint_config(
        &self,
        input: CreateEndpointConfigInput,
    ) -> Result<CreateEndpointConfigOutput, RusotoError<CreateEndpointConfigError>>;

    /// <p>Creates an SageMaker <i>experiment</i>. An experiment is a collection of <i>trials</i> that are observed, compared and evaluated as a group. A trial is a set of steps, called <i>trial components</i>, that produce a machine learning model.</p> <p>The goal of an experiment is to determine the components that produce the best model. Multiple trials are performed, each one isolating and measuring the impact of a change to one or more inputs, while keeping the remaining inputs constant.</p> <p>When you use Amazon SageMaker Studio or the Amazon SageMaker Python SDK, all experiments, trials, and trial components are automatically tracked, logged, and indexed. When you use the AWS SDK for Python (Boto), you must use the logging APIs provided by the SDK.</p> <p>You can add tags to experiments, trials, trial components and then use the <a>Search</a> API to search for the tags.</p> <p>To add a description to an experiment, specify the optional <code>Description</code> parameter. To add a description later, or to change the description, call the <a>UpdateExperiment</a> API.</p> <p>To get a list of all your experiments, call the <a>ListExperiments</a> API. To view an experiment's properties, call the <a>DescribeExperiment</a> API. To get a list of all the trials associated with an experiment, call the <a>ListTrials</a> API. To create a trial call the <a>CreateTrial</a> API.</p>
    async fn create_experiment(
        &self,
        input: CreateExperimentRequest,
    ) -> Result<CreateExperimentResponse, RusotoError<CreateExperimentError>>;

    /// <p><p>Create a new <code>FeatureGroup</code>. A <code>FeatureGroup</code> is a group of <code>Features</code> defined in the <code>FeatureStore</code> to describe a <code>Record</code>. </p> <p>The <code>FeatureGroup</code> defines the schema and features contained in the FeatureGroup. A <code>FeatureGroup</code> definition is composed of a list of <code>Features</code>, a <code>RecordIdentifierFeatureName</code>, an <code>EventTimeFeatureName</code> and configurations for its <code>OnlineStore</code> and <code>OfflineStore</code>. Check <a href="https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html">AWS service quotas</a> to see the <code>FeatureGroup</code>s quota for your AWS account.</p> <important> <p>You must include at least one of <code>OnlineStoreConfig</code> and <code>OfflineStoreConfig</code> to create a <code>FeatureGroup</code>.</p> </important></p>
    async fn create_feature_group(
        &self,
        input: CreateFeatureGroupRequest,
    ) -> Result<CreateFeatureGroupResponse, RusotoError<CreateFeatureGroupError>>;

    /// <p>Creates a flow definition.</p>
    async fn create_flow_definition(
        &self,
        input: CreateFlowDefinitionRequest,
    ) -> Result<CreateFlowDefinitionResponse, RusotoError<CreateFlowDefinitionError>>;

    /// <p>Defines the settings you will use for the human review workflow user interface. Reviewers will see a three-panel interface with an instruction area, the item to review, and an input area.</p>
    async fn create_human_task_ui(
        &self,
        input: CreateHumanTaskUiRequest,
    ) -> Result<CreateHumanTaskUiResponse, RusotoError<CreateHumanTaskUiError>>;

    /// <p>Starts a hyperparameter tuning job. A hyperparameter tuning job finds the best version of a model by running many training jobs on your dataset using the algorithm you choose and values for hyperparameters within ranges that you specify. It then chooses the hyperparameter values that result in a model that performs the best, as measured by an objective metric that you choose.</p>
    async fn create_hyper_parameter_tuning_job(
        &self,
        input: CreateHyperParameterTuningJobRequest,
    ) -> Result<
        CreateHyperParameterTuningJobResponse,
        RusotoError<CreateHyperParameterTuningJobError>,
    >;

    /// <p>Creates a custom SageMaker image. A SageMaker image is a set of image versions. Each image version represents a container image stored in Amazon Container Registry (ECR). For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/studio-byoi.html">Bring your own SageMaker image</a>.</p>
    async fn create_image(
        &self,
        input: CreateImageRequest,
    ) -> Result<CreateImageResponse, RusotoError<CreateImageError>>;

    /// <p>Creates a version of the SageMaker image specified by <code>ImageName</code>. The version represents the Amazon Container Registry (ECR) container image specified by <code>BaseImage</code>.</p>
    async fn create_image_version(
        &self,
        input: CreateImageVersionRequest,
    ) -> Result<CreateImageVersionResponse, RusotoError<CreateImageVersionError>>;

    /// <p>Creates a job that uses workers to label the data objects in your input dataset. You can use the labeled data to train machine learning models.</p> <p>You can select your workforce from one of three providers:</p> <ul> <li> <p>A private workforce that you create. It can include employees, contractors, and outside experts. Use a private workforce when want the data to stay within your organization or when a specific set of skills is required.</p> </li> <li> <p>One or more vendors that you select from the AWS Marketplace. Vendors provide expertise in specific areas. </p> </li> <li> <p>The Amazon Mechanical Turk workforce. This is the largest workforce, but it should only be used for public data or data that has been stripped of any personally identifiable information.</p> </li> </ul> <p>You can also use <i>automated data labeling</i> to reduce the number of data objects that need to be labeled by a human. Automated data labeling uses <i>active learning</i> to determine if a data object can be labeled by machine or if it needs to be sent to a human worker. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-automated-labeling.html">Using Automated Data Labeling</a>.</p> <p>The data objects to be labeled are contained in an Amazon S3 bucket. You create a <i>manifest file</i> that describes the location of each object. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data.html">Using Input and Output Data</a>.</p> <p>The output can be used as the manifest file for another labeling job or as training data for your machine learning models.</p>
    async fn create_labeling_job(
        &self,
        input: CreateLabelingJobRequest,
    ) -> Result<CreateLabelingJobResponse, RusotoError<CreateLabelingJobError>>;

    /// <p>Creates a model in Amazon SageMaker. In the request, you name the model and describe a primary container. For the primary container, you specify the Docker image that contains inference code, artifacts (from prior training), and a custom environment map that the inference code uses when you deploy the model for predictions.</p> <p>Use this API to create a model if you want to use Amazon SageMaker hosting services or run a batch transform job.</p> <p>To host your model, you create an endpoint configuration with the <code>CreateEndpointConfig</code> API, and then create an endpoint with the <code>CreateEndpoint</code> API. Amazon SageMaker then deploys all of the containers that you defined for the model in the hosting environment. </p> <p>For an example that calls this method when deploying a model to Amazon SageMaker hosting services, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/ex1-deploy-model.html#ex1-deploy-model-boto">Deploy the Model to Amazon SageMaker Hosting Services (AWS SDK for Python (Boto 3)).</a> </p> <p>To run a batch transform using your model, you start a job with the <code>CreateTransformJob</code> API. Amazon SageMaker uses your model and your dataset to get inferences which are then saved to a specified S3 location.</p> <p>In the <code>CreateModel</code> request, you must define a container with the <code>PrimaryContainer</code> parameter.</p> <p>In the request, you also provide an IAM role that Amazon SageMaker can assume to access model artifacts and docker image for deployment on ML compute hosting instances or for batch transform jobs. In addition, you also use the IAM role to manage permissions the inference code needs. For example, if the inference code access any other AWS resources, you grant necessary permissions via this role.</p>
    async fn create_model(
        &self,
        input: CreateModelInput,
    ) -> Result<CreateModelOutput, RusotoError<CreateModelError>>;

    /// <p>Creates the definition for a model bias job.</p>
    async fn create_model_bias_job_definition(
        &self,
        input: CreateModelBiasJobDefinitionRequest,
    ) -> Result<CreateModelBiasJobDefinitionResponse, RusotoError<CreateModelBiasJobDefinitionError>>;

    /// <p>Creates the definition for a model explainability job.</p>
    async fn create_model_explainability_job_definition(
        &self,
        input: CreateModelExplainabilityJobDefinitionRequest,
    ) -> Result<
        CreateModelExplainabilityJobDefinitionResponse,
        RusotoError<CreateModelExplainabilityJobDefinitionError>,
    >;

    /// <p><p>Creates a model package that you can use to create Amazon SageMaker models or list on AWS Marketplace, or a versioned model that is part of a model group. Buyers can subscribe to model packages listed on AWS Marketplace to create models in Amazon SageMaker.</p> <p>To create a model package by specifying a Docker container that contains your inference code and the Amazon S3 location of your model artifacts, provide values for <code>InferenceSpecification</code>. To create a model from an algorithm resource that you created or subscribed to in AWS Marketplace, provide a value for <code>SourceAlgorithmSpecification</code>.</p> <note> <p>There are two types of model packages:</p> <ul> <li> <p>Versioned - a model that is part of a model group in the model registry.</p> </li> <li> <p>Unversioned - a model package that is not part of a model group.</p> </li> </ul> </note></p>
    async fn create_model_package(
        &self,
        input: CreateModelPackageInput,
    ) -> Result<CreateModelPackageOutput, RusotoError<CreateModelPackageError>>;

    /// <p>Creates a model group. A model group contains a group of model versions.</p>
    async fn create_model_package_group(
        &self,
        input: CreateModelPackageGroupInput,
    ) -> Result<CreateModelPackageGroupOutput, RusotoError<CreateModelPackageGroupError>>;

    /// <p>Creates a definition for a job that monitors model quality and drift. For information about model monitor, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor.html">Amazon SageMaker Model Monitor</a>.</p>
    async fn create_model_quality_job_definition(
        &self,
        input: CreateModelQualityJobDefinitionRequest,
    ) -> Result<
        CreateModelQualityJobDefinitionResponse,
        RusotoError<CreateModelQualityJobDefinitionError>,
    >;

    /// <p>Creates a schedule that regularly starts Amazon SageMaker Processing Jobs to monitor the data captured for an Amazon SageMaker Endoint.</p>
    async fn create_monitoring_schedule(
        &self,
        input: CreateMonitoringScheduleRequest,
    ) -> Result<CreateMonitoringScheduleResponse, RusotoError<CreateMonitoringScheduleError>>;

    /// <p>Creates an Amazon SageMaker notebook instance. A notebook instance is a machine learning (ML) compute instance running on a Jupyter notebook. </p> <p>In a <code>CreateNotebookInstance</code> request, specify the type of ML compute instance that you want to run. Amazon SageMaker launches the instance, installs common libraries that you can use to explore datasets for model training, and attaches an ML storage volume to the notebook instance. </p> <p>Amazon SageMaker also provides a set of example notebooks. Each notebook demonstrates how to use Amazon SageMaker with a specific algorithm or with a machine learning framework. </p> <p>After receiving the request, Amazon SageMaker does the following:</p> <ol> <li> <p>Creates a network interface in the Amazon SageMaker VPC.</p> </li> <li> <p>(Option) If you specified <code>SubnetId</code>, Amazon SageMaker creates a network interface in your own VPC, which is inferred from the subnet ID that you provide in the input. When creating this network interface, Amazon SageMaker attaches the security group that you specified in the request to the network interface that it creates in your VPC.</p> </li> <li> <p>Launches an EC2 instance of the type specified in the request in the Amazon SageMaker VPC. If you specified <code>SubnetId</code> of your VPC, Amazon SageMaker specifies both network interfaces when launching this instance. This enables inbound traffic from your own VPC to the notebook instance, assuming that the security groups allow it.</p> </li> </ol> <p>After creating the notebook instance, Amazon SageMaker returns its Amazon Resource Name (ARN). You can't change the name of a notebook instance after you create it.</p> <p>After Amazon SageMaker creates the notebook instance, you can connect to the Jupyter server and work in Jupyter notebooks. For example, you can write code to explore a dataset that you can use for model training, train a model, host models by creating Amazon SageMaker endpoints, and validate hosted models. </p> <p>For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works.html">How It Works</a>. </p>
    async fn create_notebook_instance(
        &self,
        input: CreateNotebookInstanceInput,
    ) -> Result<CreateNotebookInstanceOutput, RusotoError<CreateNotebookInstanceError>>;

    /// <p>Creates a lifecycle configuration that you can associate with a notebook instance. A <i>lifecycle configuration</i> is a collection of shell scripts that run when you create or start a notebook instance.</p> <p>Each lifecycle configuration script has a limit of 16384 characters.</p> <p>The value of the <code>$PATH</code> environment variable that is available to both scripts is <code>/sbin:bin:/usr/sbin:/usr/bin</code>.</p> <p>View CloudWatch Logs for notebook instance lifecycle configurations in log group <code>/aws/sagemaker/NotebookInstances</code> in log stream <code>[notebook-instance-name]/[LifecycleConfigHook]</code>.</p> <p>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.</p> <p>For information about notebook instance lifestyle configurations, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/notebook-lifecycle-config.html">Step 2.1: (Optional) Customize a Notebook Instance</a>.</p>
    async fn create_notebook_instance_lifecycle_config(
        &self,
        input: CreateNotebookInstanceLifecycleConfigInput,
    ) -> Result<
        CreateNotebookInstanceLifecycleConfigOutput,
        RusotoError<CreateNotebookInstanceLifecycleConfigError>,
    >;

    /// <p>Creates a pipeline using a JSON pipeline definition.</p>
    async fn create_pipeline(
        &self,
        input: CreatePipelineRequest,
    ) -> Result<CreatePipelineResponse, RusotoError<CreatePipelineError>>;

    /// <p><p>Creates a URL for a specified UserProfile in a Domain. When accessed in a web browser, the user will be automatically signed in to Amazon SageMaker Studio, and granted access to all of the Apps and files associated with the Domain&#39;s Amazon Elastic File System (EFS) volume. This operation can only be called when the authentication mode equals IAM. </p> <note> <p>The URL that you get from a call to <code>CreatePresignedDomainUrl</code> is valid only for 5 minutes. If you try to use the URL after the 5-minute limit expires, you are directed to the AWS console sign-in page.</p> </note></p>
    async fn create_presigned_domain_url(
        &self,
        input: CreatePresignedDomainUrlRequest,
    ) -> Result<CreatePresignedDomainUrlResponse, RusotoError<CreatePresignedDomainUrlError>>;

    /// <p><p>Returns a URL that you can use to connect to the Jupyter server from a notebook instance. In the Amazon SageMaker console, when you choose <code>Open</code> next to a notebook instance, Amazon SageMaker opens a new tab showing the Jupyter server home page from the notebook instance. The console uses this API to get the URL and show the page.</p> <p> The IAM role or user used to call this API defines the permissions to access the notebook instance. Once the presigned URL is created, no additional permission is required to access this URL. IAM authorization policies for this API are also enforced for every HTTP request and WebSocket frame that attempts to connect to the notebook instance.</p> <p>You can restrict access to this API and to the URL that it returns to a list of IP addresses that you specify. Use the <code>NotIpAddress</code> condition operator and the <code>aws:SourceIP</code> condition context key to specify the list of IP addresses that you want to have access to the notebook instance. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/security_iam_id-based-policy-examples.html#nbi-ip-filter">Limit Access to a Notebook Instance by IP Address</a>.</p> <note> <p>The URL that you get from a call to <a>CreatePresignedNotebookInstanceUrl</a> is valid only for 5 minutes. If you try to use the URL after the 5-minute limit expires, you are directed to the AWS console sign-in page.</p> </note></p>
    async fn create_presigned_notebook_instance_url(
        &self,
        input: CreatePresignedNotebookInstanceUrlInput,
    ) -> Result<
        CreatePresignedNotebookInstanceUrlOutput,
        RusotoError<CreatePresignedNotebookInstanceUrlError>,
    >;

    /// <p>Creates a processing job.</p>
    async fn create_processing_job(
        &self,
        input: CreateProcessingJobRequest,
    ) -> Result<CreateProcessingJobResponse, RusotoError<CreateProcessingJobError>>;

    /// <p>Creates a machine learning (ML) project that can contain one or more templates that set up an ML pipeline from training to deploying an approved model.</p>
    async fn create_project(
        &self,
        input: CreateProjectInput,
    ) -> Result<CreateProjectOutput, RusotoError<CreateProjectError>>;

    /// <p>Starts a model training job. After training completes, Amazon SageMaker saves the resulting model artifacts to an Amazon S3 location that you specify. </p> <p>If you choose to host your model using Amazon SageMaker hosting services, you can use the resulting model artifacts as part of the model. You can also use the artifacts in a machine learning service other than Amazon SageMaker, provided that you know how to use them for inference. </p> <p>In the request body, you provide the following: </p> <ul> <li> <p> <code>AlgorithmSpecification</code> - Identifies the training algorithm to use. </p> </li> <li> <p> <code>HyperParameters</code> - Specify these algorithm-specific parameters to enable the estimation of model parameters during training. Hyperparameters can be tuned to optimize this learning process. For a list of hyperparameters for each training algorithm provided by Amazon SageMaker, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html">Algorithms</a>. </p> </li> <li> <p> <code>InputDataConfig</code> - Describes the training dataset and the Amazon S3, EFS, or FSx location where it is stored.</p> </li> <li> <p> <code>OutputDataConfig</code> - Identifies the Amazon S3 bucket where you want Amazon SageMaker to save the results of model training. </p> <p/> </li> <li> <p> <code>ResourceConfig</code> - Identifies the resources, ML compute instances, and ML storage volumes to deploy for model training. In distributed training, you specify more than one instance. </p> </li> <li> <p> <code>EnableManagedSpotTraining</code> - Optimize the cost of training machine learning models by up to 80% by using Amazon EC2 Spot instances. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html">Managed Spot Training</a>. </p> </li> <li> <p> <code>RoleArn</code> - The Amazon Resource Number (ARN) that Amazon SageMaker assumes to perform tasks on your behalf during model training. You must grant this role the necessary permissions so that Amazon SageMaker can successfully complete model training. </p> </li> <li> <p> <code>StoppingCondition</code> - To help cap training costs, use <code>MaxRuntimeInSeconds</code> to set a time limit for training. Use <code>MaxWaitTimeInSeconds</code> to specify how long you are willing to wait for a managed spot training job to complete. </p> </li> </ul> <p> For more information about Amazon SageMaker, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works.html">How It Works</a>. </p>
    async fn create_training_job(
        &self,
        input: CreateTrainingJobRequest,
    ) -> Result<CreateTrainingJobResponse, RusotoError<CreateTrainingJobError>>;

    /// <p>Starts a transform job. A transform job uses a trained model to get inferences on a dataset and saves these results to an Amazon S3 location that you specify.</p> <p>To perform batch transformations, you create a transform job and use the data that you have readily available.</p> <p>In the request body, you provide the following:</p> <ul> <li> <p> <code>TransformJobName</code> - Identifies the transform job. The name must be unique within an AWS Region in an AWS account.</p> </li> <li> <p> <code>ModelName</code> - Identifies the model to use. <code>ModelName</code> must be the name of an existing Amazon SageMaker model in the same AWS Region and AWS account. For information on creating a model, see <a>CreateModel</a>.</p> </li> <li> <p> <code>TransformInput</code> - Describes the dataset to be transformed and the Amazon S3 location where it is stored.</p> </li> <li> <p> <code>TransformOutput</code> - Identifies the Amazon S3 location where you want Amazon SageMaker to save the results from the transform job.</p> </li> <li> <p> <code>TransformResources</code> - Identifies the ML compute instances for the transform job.</p> </li> </ul> <p>For more information about how batch transformation works, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform.html">Batch Transform</a>.</p>
    async fn create_transform_job(
        &self,
        input: CreateTransformJobRequest,
    ) -> Result<CreateTransformJobResponse, RusotoError<CreateTransformJobError>>;

    /// <p>Creates an Amazon SageMaker <i>trial</i>. A trial is a set of steps called <i>trial components</i> that produce a machine learning model. A trial is part of a single Amazon SageMaker <i>experiment</i>.</p> <p>When you use Amazon SageMaker Studio or the Amazon SageMaker Python SDK, all experiments, trials, and trial components are automatically tracked, logged, and indexed. When you use the AWS SDK for Python (Boto), you must use the logging APIs provided by the SDK.</p> <p>You can add tags to a trial and then use the <a>Search</a> API to search for the tags.</p> <p>To get a list of all your trials, call the <a>ListTrials</a> API. To view a trial's properties, call the <a>DescribeTrial</a> API. To create a trial component, call the <a>CreateTrialComponent</a> API.</p>
    async fn create_trial(
        &self,
        input: CreateTrialRequest,
    ) -> Result<CreateTrialResponse, RusotoError<CreateTrialError>>;

    /// <p><p>Creates a <i>trial component</i>, which is a stage of a machine learning <i>trial</i>. A trial is composed of one or more trial components. A trial component can be used in multiple trials.</p> <p>Trial components include pre-processing jobs, training jobs, and batch transform jobs.</p> <p>When you use Amazon SageMaker Studio or the Amazon SageMaker Python SDK, all experiments, trials, and trial components are automatically tracked, logged, and indexed. When you use the AWS SDK for Python (Boto), you must use the logging APIs provided by the SDK.</p> <p>You can add tags to a trial component and then use the <a>Search</a> API to search for the tags.</p> <note> <p> <code>CreateTrialComponent</code> can only be invoked from within an Amazon SageMaker managed environment. This includes Amazon SageMaker training jobs, processing jobs, transform jobs, and Amazon SageMaker notebooks. A call to <code>CreateTrialComponent</code> from outside one of these environments results in an error.</p> </note></p>
    async fn create_trial_component(
        &self,
        input: CreateTrialComponentRequest,
    ) -> Result<CreateTrialComponentResponse, RusotoError<CreateTrialComponentError>>;

    /// <p>Creates a user profile. A user profile represents a single user within a domain, and is the main way to reference a "person" for the purposes of sharing, reporting, and other user-oriented features. This entity is created when a user onboards to Amazon SageMaker Studio. If an administrator invites a person by email or imports them from SSO, a user profile is automatically created. A user profile is the primary holder of settings for an individual user and has a reference to the user's private Amazon Elastic File System (EFS) home directory. </p>
    async fn create_user_profile(
        &self,
        input: CreateUserProfileRequest,
    ) -> Result<CreateUserProfileResponse, RusotoError<CreateUserProfileError>>;

    /// <p>Use this operation to create a workforce. This operation will return an error if a workforce already exists in the AWS Region that you specify. You can only create one workforce in each AWS Region per AWS account.</p> <p>If you want to create a new workforce in an AWS Region where a workforce already exists, use the API operation to delete the existing workforce and then use <code>CreateWorkforce</code> to create a new workforce.</p> <p>To create a private workforce using Amazon Cognito, you must specify a Cognito user pool in <code>CognitoConfig</code>. You can also create an Amazon Cognito workforce using the Amazon SageMaker console. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-create-private.html"> Create a Private Workforce (Amazon Cognito)</a>.</p> <p>To create a private workforce using your own OIDC Identity Provider (IdP), specify your IdP configuration in <code>OidcConfig</code>. Your OIDC IdP must support <i>groups</i> because groups are used by Ground Truth and Amazon A2I to create work teams. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-create-private-oidc.html"> Create a Private Workforce (OIDC IdP)</a>.</p>
    async fn create_workforce(
        &self,
        input: CreateWorkforceRequest,
    ) -> Result<CreateWorkforceResponse, RusotoError<CreateWorkforceError>>;

    /// <p>Creates a new work team for labeling your data. A work team is defined by one or more Amazon Cognito user pools. You must first create the user pools before you can create a work team.</p> <p>You cannot create more than 25 work teams in an account and region.</p>
    async fn create_workteam(
        &self,
        input: CreateWorkteamRequest,
    ) -> Result<CreateWorkteamResponse, RusotoError<CreateWorkteamError>>;

    /// <p>Deletes an action.</p>
    async fn delete_action(
        &self,
        input: DeleteActionRequest,
    ) -> Result<DeleteActionResponse, RusotoError<DeleteActionError>>;

    /// <p>Removes the specified algorithm from your account.</p>
    async fn delete_algorithm(
        &self,
        input: DeleteAlgorithmInput,
    ) -> Result<(), RusotoError<DeleteAlgorithmError>>;

    /// <p>Used to stop and delete an app.</p>
    async fn delete_app(&self, input: DeleteAppRequest) -> Result<(), RusotoError<DeleteAppError>>;

    /// <p>Deletes an AppImageConfig.</p>
    async fn delete_app_image_config(
        &self,
        input: DeleteAppImageConfigRequest,
    ) -> Result<(), RusotoError<DeleteAppImageConfigError>>;

    /// <p>Deletes an artifact. Either <code>ArtifactArn</code> or <code>Source</code> must be specified.</p>
    async fn delete_artifact(
        &self,
        input: DeleteArtifactRequest,
    ) -> Result<DeleteArtifactResponse, RusotoError<DeleteArtifactError>>;

    /// <p>Deletes an association.</p>
    async fn delete_association(
        &self,
        input: DeleteAssociationRequest,
    ) -> Result<DeleteAssociationResponse, RusotoError<DeleteAssociationError>>;

    /// <p>Deletes the specified Git repository from your account.</p>
    async fn delete_code_repository(
        &self,
        input: DeleteCodeRepositoryInput,
    ) -> Result<(), RusotoError<DeleteCodeRepositoryError>>;

    /// <p>Deletes an context.</p>
    async fn delete_context(
        &self,
        input: DeleteContextRequest,
    ) -> Result<DeleteContextResponse, RusotoError<DeleteContextError>>;

    /// <p>Deletes a data quality monitoring job definition.</p>
    async fn delete_data_quality_job_definition(
        &self,
        input: DeleteDataQualityJobDefinitionRequest,
    ) -> Result<(), RusotoError<DeleteDataQualityJobDefinitionError>>;

    /// <p>Deletes a fleet.</p>
    async fn delete_device_fleet(
        &self,
        input: DeleteDeviceFleetRequest,
    ) -> Result<(), RusotoError<DeleteDeviceFleetError>>;

    /// <p>Used to delete a domain. If you onboarded with IAM mode, you will need to delete your domain to onboard again using SSO. Use with caution. All of the members of the domain will lose access to their EFS volume, including data, notebooks, and other artifacts. </p>
    async fn delete_domain(
        &self,
        input: DeleteDomainRequest,
    ) -> Result<(), RusotoError<DeleteDomainError>>;

    /// <p>Deletes an endpoint. Amazon SageMaker frees up all of the resources that were deployed when the endpoint was created. </p> <p>Amazon SageMaker retires any custom KMS key grants associated with the endpoint, meaning you don't need to use the <a href="http://docs.aws.amazon.com/kms/latest/APIReference/API_RevokeGrant.html">RevokeGrant</a> API call.</p>
    async fn delete_endpoint(
        &self,
        input: DeleteEndpointInput,
    ) -> Result<(), RusotoError<DeleteEndpointError>>;

    /// <p>Deletes an endpoint configuration. The <code>DeleteEndpointConfig</code> API deletes only the specified configuration. It does not delete endpoints created using the configuration. </p> <p>You must not delete an <code>EndpointConfig</code> in use by an endpoint that is live or while the <code>UpdateEndpoint</code> or <code>CreateEndpoint</code> operations are being performed on the endpoint. If you delete the <code>EndpointConfig</code> of an endpoint that is active or being created or updated you may lose visibility into the instance type the endpoint is using. The endpoint must be deleted in order to stop incurring charges.</p>
    async fn delete_endpoint_config(
        &self,
        input: DeleteEndpointConfigInput,
    ) -> Result<(), RusotoError<DeleteEndpointConfigError>>;

    /// <p>Deletes an Amazon SageMaker experiment. All trials associated with the experiment must be deleted first. Use the <a>ListTrials</a> API to get a list of the trials associated with the experiment.</p>
    async fn delete_experiment(
        &self,
        input: DeleteExperimentRequest,
    ) -> Result<DeleteExperimentResponse, RusotoError<DeleteExperimentError>>;

    /// <p>Delete the <code>FeatureGroup</code> and any data that was written to the <code>OnlineStore</code> of the <code>FeatureGroup</code>. Data cannot be accessed from the <code>OnlineStore</code> immediately after <code>DeleteFeatureGroup</code> is called. </p> <p>Data written into the <code>OfflineStore</code> will not be deleted. The AWS Glue database and tables that are automatically created for your <code>OfflineStore</code> are not deleted. </p>
    async fn delete_feature_group(
        &self,
        input: DeleteFeatureGroupRequest,
    ) -> Result<(), RusotoError<DeleteFeatureGroupError>>;

    /// <p>Deletes the specified flow definition.</p>
    async fn delete_flow_definition(
        &self,
        input: DeleteFlowDefinitionRequest,
    ) -> Result<DeleteFlowDefinitionResponse, RusotoError<DeleteFlowDefinitionError>>;

    /// <p>Use this operation to delete a human task user interface (worker task template).</p> <p> To see a list of human task user interfaces (work task templates) in your account, use . When you delete a worker task template, it no longer appears when you call <code>ListHumanTaskUis</code>.</p>
    async fn delete_human_task_ui(
        &self,
        input: DeleteHumanTaskUiRequest,
    ) -> Result<DeleteHumanTaskUiResponse, RusotoError<DeleteHumanTaskUiError>>;

    /// <p>Deletes a SageMaker image and all versions of the image. The container images aren't deleted.</p>
    async fn delete_image(
        &self,
        input: DeleteImageRequest,
    ) -> Result<DeleteImageResponse, RusotoError<DeleteImageError>>;

    /// <p>Deletes a version of a SageMaker image. The container image the version represents isn't deleted.</p>
    async fn delete_image_version(
        &self,
        input: DeleteImageVersionRequest,
    ) -> Result<DeleteImageVersionResponse, RusotoError<DeleteImageVersionError>>;

    /// <p>Deletes a model. The <code>DeleteModel</code> API deletes only the model entry that was created in Amazon SageMaker when you called the <a>CreateModel</a> API. It does not delete model artifacts, inference code, or the IAM role that you specified when creating the model. </p>
    async fn delete_model(
        &self,
        input: DeleteModelInput,
    ) -> Result<(), RusotoError<DeleteModelError>>;

    /// <p>Deletes an Amazon SageMaker model bias job definition.</p>
    async fn delete_model_bias_job_definition(
        &self,
        input: DeleteModelBiasJobDefinitionRequest,
    ) -> Result<(), RusotoError<DeleteModelBiasJobDefinitionError>>;

    /// <p>Deletes an Amazon SageMaker model explainability job definition.</p>
    async fn delete_model_explainability_job_definition(
        &self,
        input: DeleteModelExplainabilityJobDefinitionRequest,
    ) -> Result<(), RusotoError<DeleteModelExplainabilityJobDefinitionError>>;

    /// <p>Deletes a model package.</p> <p>A model package is used to create Amazon SageMaker models or list on AWS Marketplace. Buyers can subscribe to model packages listed on AWS Marketplace to create models in Amazon SageMaker.</p>
    async fn delete_model_package(
        &self,
        input: DeleteModelPackageInput,
    ) -> Result<(), RusotoError<DeleteModelPackageError>>;

    /// <p>Deletes the specified model group.</p>
    async fn delete_model_package_group(
        &self,
        input: DeleteModelPackageGroupInput,
    ) -> Result<(), RusotoError<DeleteModelPackageGroupError>>;

    /// <p>Deletes a model group resource policy.</p>
    async fn delete_model_package_group_policy(
        &self,
        input: DeleteModelPackageGroupPolicyInput,
    ) -> Result<(), RusotoError<DeleteModelPackageGroupPolicyError>>;

    /// <p>Deletes the secified model quality monitoring job definition.</p>
    async fn delete_model_quality_job_definition(
        &self,
        input: DeleteModelQualityJobDefinitionRequest,
    ) -> Result<(), RusotoError<DeleteModelQualityJobDefinitionError>>;

    /// <p>Deletes a monitoring schedule. Also stops the schedule had not already been stopped. This does not delete the job execution history of the monitoring schedule. </p>
    async fn delete_monitoring_schedule(
        &self,
        input: DeleteMonitoringScheduleRequest,
    ) -> Result<(), RusotoError<DeleteMonitoringScheduleError>>;

    /// <p><p> Deletes an Amazon SageMaker notebook instance. Before you can delete a notebook instance, you must call the <code>StopNotebookInstance</code> API. </p> <important> <p>When you delete a notebook instance, you lose all of your data. Amazon SageMaker removes the ML compute instance, and deletes the ML storage volume and the network interface associated with the notebook instance. </p> </important></p>
    async fn delete_notebook_instance(
        &self,
        input: DeleteNotebookInstanceInput,
    ) -> Result<(), RusotoError<DeleteNotebookInstanceError>>;

    /// <p>Deletes a notebook instance lifecycle configuration.</p>
    async fn delete_notebook_instance_lifecycle_config(
        &self,
        input: DeleteNotebookInstanceLifecycleConfigInput,
    ) -> Result<(), RusotoError<DeleteNotebookInstanceLifecycleConfigError>>;

    /// <p>Deletes a pipeline if there are no in-progress executions.</p>
    async fn delete_pipeline(
        &self,
        input: DeletePipelineRequest,
    ) -> Result<DeletePipelineResponse, RusotoError<DeletePipelineError>>;

    /// <p>Delete the specified project.</p>
    async fn delete_project(
        &self,
        input: DeleteProjectInput,
    ) -> Result<(), RusotoError<DeleteProjectError>>;

    /// <p><p>Deletes the specified tags from an Amazon SageMaker resource.</p> <p>To list a resource&#39;s tags, use the <code>ListTags</code> API. </p> <note> <p>When you call this API to delete tags from a hyperparameter tuning job, the deleted tags are not removed from training jobs that the hyperparameter tuning job launched before you called this API.</p> </note></p>
    async fn delete_tags(
        &self,
        input: DeleteTagsInput,
    ) -> Result<DeleteTagsOutput, RusotoError<DeleteTagsError>>;

    /// <p>Deletes the specified trial. All trial components that make up the trial must be deleted first. Use the <a>DescribeTrialComponent</a> API to get the list of trial components.</p>
    async fn delete_trial(
        &self,
        input: DeleteTrialRequest,
    ) -> Result<DeleteTrialResponse, RusotoError<DeleteTrialError>>;

    /// <p>Deletes the specified trial component. A trial component must be disassociated from all trials before the trial component can be deleted. To disassociate a trial component from a trial, call the <a>DisassociateTrialComponent</a> API.</p>
    async fn delete_trial_component(
        &self,
        input: DeleteTrialComponentRequest,
    ) -> Result<DeleteTrialComponentResponse, RusotoError<DeleteTrialComponentError>>;

    /// <p>Deletes a user profile. When a user profile is deleted, the user loses access to their EFS volume, including data, notebooks, and other artifacts.</p>
    async fn delete_user_profile(
        &self,
        input: DeleteUserProfileRequest,
    ) -> Result<(), RusotoError<DeleteUserProfileError>>;

    /// <p><p>Use this operation to delete a workforce.</p> <p>If you want to create a new workforce in an AWS Region where a workforce already exists, use this operation to delete the existing workforce and then use to create a new workforce.</p> <important> <p>If a private workforce contains one or more work teams, you must use the operation to delete all work teams before you delete the workforce. If you try to delete a workforce that contains one or more work teams, you will recieve a <code>ResourceInUse</code> error.</p> </important></p>
    async fn delete_workforce(
        &self,
        input: DeleteWorkforceRequest,
    ) -> Result<DeleteWorkforceResponse, RusotoError<DeleteWorkforceError>>;

    /// <p>Deletes an existing work team. This operation can't be undone.</p>
    async fn delete_workteam(
        &self,
        input: DeleteWorkteamRequest,
    ) -> Result<DeleteWorkteamResponse, RusotoError<DeleteWorkteamError>>;

    /// <p>Deregisters the specified devices. After you deregister a device, you will need to re-register the devices.</p>
    async fn deregister_devices(
        &self,
        input: DeregisterDevicesRequest,
    ) -> Result<(), RusotoError<DeregisterDevicesError>>;

    /// <p>Describes an action.</p>
    async fn describe_action(
        &self,
        input: DescribeActionRequest,
    ) -> Result<DescribeActionResponse, RusotoError<DescribeActionError>>;

    /// <p>Returns a description of the specified algorithm that is in your account.</p>
    async fn describe_algorithm(
        &self,
        input: DescribeAlgorithmInput,
    ) -> Result<DescribeAlgorithmOutput, RusotoError<DescribeAlgorithmError>>;

    /// <p>Describes the app.</p>
    async fn describe_app(
        &self,
        input: DescribeAppRequest,
    ) -> Result<DescribeAppResponse, RusotoError<DescribeAppError>>;

    /// <p>Describes an AppImageConfig.</p>
    async fn describe_app_image_config(
        &self,
        input: DescribeAppImageConfigRequest,
    ) -> Result<DescribeAppImageConfigResponse, RusotoError<DescribeAppImageConfigError>>;

    /// <p>Describes an artifact.</p>
    async fn describe_artifact(
        &self,
        input: DescribeArtifactRequest,
    ) -> Result<DescribeArtifactResponse, RusotoError<DescribeArtifactError>>;

    /// <p>Returns information about an Amazon SageMaker job.</p>
    async fn describe_auto_ml_job(
        &self,
        input: DescribeAutoMLJobRequest,
    ) -> Result<DescribeAutoMLJobResponse, RusotoError<DescribeAutoMLJobError>>;

    /// <p>Gets details about the specified Git repository.</p>
    async fn describe_code_repository(
        &self,
        input: DescribeCodeRepositoryInput,
    ) -> Result<DescribeCodeRepositoryOutput, RusotoError<DescribeCodeRepositoryError>>;

    /// <p>Returns information about a model compilation job.</p> <p>To create a model compilation job, use <a>CreateCompilationJob</a>. To get information about multiple model compilation jobs, use <a>ListCompilationJobs</a>.</p>
    async fn describe_compilation_job(
        &self,
        input: DescribeCompilationJobRequest,
    ) -> Result<DescribeCompilationJobResponse, RusotoError<DescribeCompilationJobError>>;

    /// <p>Describes a context.</p>
    async fn describe_context(
        &self,
        input: DescribeContextRequest,
    ) -> Result<DescribeContextResponse, RusotoError<DescribeContextError>>;

    /// <p>Gets the details of a data quality monitoring job definition.</p>
    async fn describe_data_quality_job_definition(
        &self,
        input: DescribeDataQualityJobDefinitionRequest,
    ) -> Result<
        DescribeDataQualityJobDefinitionResponse,
        RusotoError<DescribeDataQualityJobDefinitionError>,
    >;

    /// <p>Describes the device.</p>
    async fn describe_device(
        &self,
        input: DescribeDeviceRequest,
    ) -> Result<DescribeDeviceResponse, RusotoError<DescribeDeviceError>>;

    /// <p>A description of the fleet the device belongs to.</p>
    async fn describe_device_fleet(
        &self,
        input: DescribeDeviceFleetRequest,
    ) -> Result<DescribeDeviceFleetResponse, RusotoError<DescribeDeviceFleetError>>;

    /// <p>The description of the domain.</p>
    async fn describe_domain(
        &self,
        input: DescribeDomainRequest,
    ) -> Result<DescribeDomainResponse, RusotoError<DescribeDomainError>>;

    /// <p>A description of edge packaging jobs.</p>
    async fn describe_edge_packaging_job(
        &self,
        input: DescribeEdgePackagingJobRequest,
    ) -> Result<DescribeEdgePackagingJobResponse, RusotoError<DescribeEdgePackagingJobError>>;

    /// <p>Returns the description of an endpoint.</p>
    async fn describe_endpoint(
        &self,
        input: DescribeEndpointInput,
    ) -> Result<DescribeEndpointOutput, RusotoError<DescribeEndpointError>>;

    /// <p>Returns the description of an endpoint configuration created using the <code>CreateEndpointConfig</code> API.</p>
    async fn describe_endpoint_config(
        &self,
        input: DescribeEndpointConfigInput,
    ) -> Result<DescribeEndpointConfigOutput, RusotoError<DescribeEndpointConfigError>>;

    /// <p>Provides a list of an experiment's properties.</p>
    async fn describe_experiment(
        &self,
        input: DescribeExperimentRequest,
    ) -> Result<DescribeExperimentResponse, RusotoError<DescribeExperimentError>>;

    /// <p>Use this operation to describe a <code>FeatureGroup</code>. The response includes information on the creation time, <code>FeatureGroup</code> name, the unique identifier for each <code>FeatureGroup</code>, and more.</p>
    async fn describe_feature_group(
        &self,
        input: DescribeFeatureGroupRequest,
    ) -> Result<DescribeFeatureGroupResponse, RusotoError<DescribeFeatureGroupError>>;

    /// <p>Returns information about the specified flow definition.</p>
    async fn describe_flow_definition(
        &self,
        input: DescribeFlowDefinitionRequest,
    ) -> Result<DescribeFlowDefinitionResponse, RusotoError<DescribeFlowDefinitionError>>;

    /// <p>Returns information about the requested human task user interface (worker task template).</p>
    async fn describe_human_task_ui(
        &self,
        input: DescribeHumanTaskUiRequest,
    ) -> Result<DescribeHumanTaskUiResponse, RusotoError<DescribeHumanTaskUiError>>;

    /// <p>Gets a description of a hyperparameter tuning job.</p>
    async fn describe_hyper_parameter_tuning_job(
        &self,
        input: DescribeHyperParameterTuningJobRequest,
    ) -> Result<
        DescribeHyperParameterTuningJobResponse,
        RusotoError<DescribeHyperParameterTuningJobError>,
    >;

    /// <p>Describes a SageMaker image.</p>
    async fn describe_image(
        &self,
        input: DescribeImageRequest,
    ) -> Result<DescribeImageResponse, RusotoError<DescribeImageError>>;

    /// <p>Describes a version of a SageMaker image.</p>
    async fn describe_image_version(
        &self,
        input: DescribeImageVersionRequest,
    ) -> Result<DescribeImageVersionResponse, RusotoError<DescribeImageVersionError>>;

    /// <p>Gets information about a labeling job.</p>
    async fn describe_labeling_job(
        &self,
        input: DescribeLabelingJobRequest,
    ) -> Result<DescribeLabelingJobResponse, RusotoError<DescribeLabelingJobError>>;

    /// <p>Describes a model that you created using the <code>CreateModel</code> API.</p>
    async fn describe_model(
        &self,
        input: DescribeModelInput,
    ) -> Result<DescribeModelOutput, RusotoError<DescribeModelError>>;

    /// <p>Returns a description of a model bias job definition.</p>
    async fn describe_model_bias_job_definition(
        &self,
        input: DescribeModelBiasJobDefinitionRequest,
    ) -> Result<
        DescribeModelBiasJobDefinitionResponse,
        RusotoError<DescribeModelBiasJobDefinitionError>,
    >;

    /// <p>Returns a description of a model explainability job definition.</p>
    async fn describe_model_explainability_job_definition(
        &self,
        input: DescribeModelExplainabilityJobDefinitionRequest,
    ) -> Result<
        DescribeModelExplainabilityJobDefinitionResponse,
        RusotoError<DescribeModelExplainabilityJobDefinitionError>,
    >;

    /// <p>Returns a description of the specified model package, which is used to create Amazon SageMaker models or list them on AWS Marketplace.</p> <p>To create models in Amazon SageMaker, buyers can subscribe to model packages listed on AWS Marketplace.</p>
    async fn describe_model_package(
        &self,
        input: DescribeModelPackageInput,
    ) -> Result<DescribeModelPackageOutput, RusotoError<DescribeModelPackageError>>;

    /// <p>Gets a description for the specified model group.</p>
    async fn describe_model_package_group(
        &self,
        input: DescribeModelPackageGroupInput,
    ) -> Result<DescribeModelPackageGroupOutput, RusotoError<DescribeModelPackageGroupError>>;

    /// <p>Returns a description of a model quality job definition.</p>
    async fn describe_model_quality_job_definition(
        &self,
        input: DescribeModelQualityJobDefinitionRequest,
    ) -> Result<
        DescribeModelQualityJobDefinitionResponse,
        RusotoError<DescribeModelQualityJobDefinitionError>,
    >;

    /// <p>Describes the schedule for a monitoring job.</p>
    async fn describe_monitoring_schedule(
        &self,
        input: DescribeMonitoringScheduleRequest,
    ) -> Result<DescribeMonitoringScheduleResponse, RusotoError<DescribeMonitoringScheduleError>>;

    /// <p>Returns information about a notebook instance.</p>
    async fn describe_notebook_instance(
        &self,
        input: DescribeNotebookInstanceInput,
    ) -> Result<DescribeNotebookInstanceOutput, RusotoError<DescribeNotebookInstanceError>>;

    /// <p>Returns a description of a notebook instance lifecycle configuration.</p> <p>For information about notebook instance lifestyle configurations, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/notebook-lifecycle-config.html">Step 2.1: (Optional) Customize a Notebook Instance</a>.</p>
    async fn describe_notebook_instance_lifecycle_config(
        &self,
        input: DescribeNotebookInstanceLifecycleConfigInput,
    ) -> Result<
        DescribeNotebookInstanceLifecycleConfigOutput,
        RusotoError<DescribeNotebookInstanceLifecycleConfigError>,
    >;

    /// <p>Describes the details of a pipeline.</p>
    async fn describe_pipeline(
        &self,
        input: DescribePipelineRequest,
    ) -> Result<DescribePipelineResponse, RusotoError<DescribePipelineError>>;

    /// <p>Describes the details of an execution's pipeline definition.</p>
    async fn describe_pipeline_definition_for_execution(
        &self,
        input: DescribePipelineDefinitionForExecutionRequest,
    ) -> Result<
        DescribePipelineDefinitionForExecutionResponse,
        RusotoError<DescribePipelineDefinitionForExecutionError>,
    >;

    /// <p>Describes the details of a pipeline execution.</p>
    async fn describe_pipeline_execution(
        &self,
        input: DescribePipelineExecutionRequest,
    ) -> Result<DescribePipelineExecutionResponse, RusotoError<DescribePipelineExecutionError>>;

    /// <p>Returns a description of a processing job.</p>
    async fn describe_processing_job(
        &self,
        input: DescribeProcessingJobRequest,
    ) -> Result<DescribeProcessingJobResponse, RusotoError<DescribeProcessingJobError>>;

    /// <p>Describes the details of a project.</p>
    async fn describe_project(
        &self,
        input: DescribeProjectInput,
    ) -> Result<DescribeProjectOutput, RusotoError<DescribeProjectError>>;

    /// <p>Gets information about a work team provided by a vendor. It returns details about the subscription with a vendor in the AWS Marketplace.</p>
    async fn describe_subscribed_workteam(
        &self,
        input: DescribeSubscribedWorkteamRequest,
    ) -> Result<DescribeSubscribedWorkteamResponse, RusotoError<DescribeSubscribedWorkteamError>>;

    /// <p>Returns information about a training job.</p>
    async fn describe_training_job(
        &self,
        input: DescribeTrainingJobRequest,
    ) -> Result<DescribeTrainingJobResponse, RusotoError<DescribeTrainingJobError>>;

    /// <p>Returns information about a transform job.</p>
    async fn describe_transform_job(
        &self,
        input: DescribeTransformJobRequest,
    ) -> Result<DescribeTransformJobResponse, RusotoError<DescribeTransformJobError>>;

    /// <p>Provides a list of a trial's properties.</p>
    async fn describe_trial(
        &self,
        input: DescribeTrialRequest,
    ) -> Result<DescribeTrialResponse, RusotoError<DescribeTrialError>>;

    /// <p>Provides a list of a trials component's properties.</p>
    async fn describe_trial_component(
        &self,
        input: DescribeTrialComponentRequest,
    ) -> Result<DescribeTrialComponentResponse, RusotoError<DescribeTrialComponentError>>;

    /// <p>Describes a user profile. For more information, see <code>CreateUserProfile</code>.</p>
    async fn describe_user_profile(
        &self,
        input: DescribeUserProfileRequest,
    ) -> Result<DescribeUserProfileResponse, RusotoError<DescribeUserProfileError>>;

    /// <p><p>Lists private workforce information, including workforce name, Amazon Resource Name (ARN), and, if applicable, allowed IP address ranges (<a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html">CIDRs</a>). Allowable IP address ranges are the IP addresses that workers can use to access tasks. </p> <important> <p>This operation applies only to private workforces.</p> </important></p>
    async fn describe_workforce(
        &self,
        input: DescribeWorkforceRequest,
    ) -> Result<DescribeWorkforceResponse, RusotoError<DescribeWorkforceError>>;

    /// <p>Gets information about a specific work team. You can see information such as the create date, the last updated date, membership information, and the work team's Amazon Resource Name (ARN).</p>
    async fn describe_workteam(
        &self,
        input: DescribeWorkteamRequest,
    ) -> Result<DescribeWorkteamResponse, RusotoError<DescribeWorkteamError>>;

    /// <p>Disables using Service Catalog in SageMaker. Service Catalog is used to create SageMaker projects.</p>
    async fn disable_sagemaker_servicecatalog_portfolio(
        &self,
    ) -> Result<
        DisableSagemakerServicecatalogPortfolioOutput,
        RusotoError<DisableSagemakerServicecatalogPortfolioError>,
    >;

    /// <p>Disassociates a trial component from a trial. This doesn't effect other trials the component is associated with. Before you can delete a component, you must disassociate the component from all trials it is associated with. To associate a trial component with a trial, call the <a>AssociateTrialComponent</a> API.</p> <p>To get a list of the trials a component is associated with, use the <a>Search</a> API. Specify <code>ExperimentTrialComponent</code> for the <code>Resource</code> parameter. The list appears in the response under <code>Results.TrialComponent.Parents</code>.</p>
    async fn disassociate_trial_component(
        &self,
        input: DisassociateTrialComponentRequest,
    ) -> Result<DisassociateTrialComponentResponse, RusotoError<DisassociateTrialComponentError>>;

    /// <p>Enables using Service Catalog in SageMaker. Service Catalog is used to create SageMaker projects.</p>
    async fn enable_sagemaker_servicecatalog_portfolio(
        &self,
    ) -> Result<
        EnableSagemakerServicecatalogPortfolioOutput,
        RusotoError<EnableSagemakerServicecatalogPortfolioError>,
    >;

    /// <p>Describes a fleet.</p>
    async fn get_device_fleet_report(
        &self,
        input: GetDeviceFleetReportRequest,
    ) -> Result<GetDeviceFleetReportResponse, RusotoError<GetDeviceFleetReportError>>;

    /// <p>Gets a resource policy that manages access for a model group. For information about resource policies, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html">Identity-based policies and resource-based policies</a> in the <i>AWS Identity and Access Management User Guide.</i>.</p>
    async fn get_model_package_group_policy(
        &self,
        input: GetModelPackageGroupPolicyInput,
    ) -> Result<GetModelPackageGroupPolicyOutput, RusotoError<GetModelPackageGroupPolicyError>>;

    /// <p>Gets the status of Service Catalog in SageMaker. Service Catalog is used to create SageMaker projects.</p>
    async fn get_sagemaker_servicecatalog_portfolio_status(
        &self,
    ) -> Result<
        GetSagemakerServicecatalogPortfolioStatusOutput,
        RusotoError<GetSagemakerServicecatalogPortfolioStatusError>,
    >;

    /// <p>An auto-complete API for the search functionality in the Amazon SageMaker console. It returns suggestions of possible matches for the property name to use in <code>Search</code> queries. Provides suggestions for <code>HyperParameters</code>, <code>Tags</code>, and <code>Metrics</code>.</p>
    async fn get_search_suggestions(
        &self,
        input: GetSearchSuggestionsRequest,
    ) -> Result<GetSearchSuggestionsResponse, RusotoError<GetSearchSuggestionsError>>;

    /// <p>Lists the actions in your account and their properties.</p>
    async fn list_actions(
        &self,
        input: ListActionsRequest,
    ) -> Result<ListActionsResponse, RusotoError<ListActionsError>>;

    /// <p>Lists the machine learning algorithms that have been created.</p>
    async fn list_algorithms(
        &self,
        input: ListAlgorithmsInput,
    ) -> Result<ListAlgorithmsOutput, RusotoError<ListAlgorithmsError>>;

    /// <p>Lists the AppImageConfigs in your account and their properties. The list can be filtered by creation time or modified time, and whether the AppImageConfig name contains a specified string.</p>
    async fn list_app_image_configs(
        &self,
        input: ListAppImageConfigsRequest,
    ) -> Result<ListAppImageConfigsResponse, RusotoError<ListAppImageConfigsError>>;

    /// <p>Lists apps.</p>
    async fn list_apps(
        &self,
        input: ListAppsRequest,
    ) -> Result<ListAppsResponse, RusotoError<ListAppsError>>;

    /// <p>Lists the artifacts in your account and their properties.</p>
    async fn list_artifacts(
        &self,
        input: ListArtifactsRequest,
    ) -> Result<ListArtifactsResponse, RusotoError<ListArtifactsError>>;

    /// <p>Lists the associations in your account and their properties.</p>
    async fn list_associations(
        &self,
        input: ListAssociationsRequest,
    ) -> Result<ListAssociationsResponse, RusotoError<ListAssociationsError>>;

    /// <p>Request a list of jobs.</p>
    async fn list_auto_ml_jobs(
        &self,
        input: ListAutoMLJobsRequest,
    ) -> Result<ListAutoMLJobsResponse, RusotoError<ListAutoMLJobsError>>;

    /// <p>List the Candidates created for the job.</p>
    async fn list_candidates_for_auto_ml_job(
        &self,
        input: ListCandidatesForAutoMLJobRequest,
    ) -> Result<ListCandidatesForAutoMLJobResponse, RusotoError<ListCandidatesForAutoMLJobError>>;

    /// <p>Gets a list of the Git repositories in your account.</p>
    async fn list_code_repositories(
        &self,
        input: ListCodeRepositoriesInput,
    ) -> Result<ListCodeRepositoriesOutput, RusotoError<ListCodeRepositoriesError>>;

    /// <p>Lists model compilation jobs that satisfy various filters.</p> <p>To create a model compilation job, use <a>CreateCompilationJob</a>. To get information about a particular model compilation job you have created, use <a>DescribeCompilationJob</a>.</p>
    async fn list_compilation_jobs(
        &self,
        input: ListCompilationJobsRequest,
    ) -> Result<ListCompilationJobsResponse, RusotoError<ListCompilationJobsError>>;

    /// <p>Lists the contexts in your account and their properties.</p>
    async fn list_contexts(
        &self,
        input: ListContextsRequest,
    ) -> Result<ListContextsResponse, RusotoError<ListContextsError>>;

    /// <p>Lists the data quality job definitions in your account.</p>
    async fn list_data_quality_job_definitions(
        &self,
        input: ListDataQualityJobDefinitionsRequest,
    ) -> Result<
        ListDataQualityJobDefinitionsResponse,
        RusotoError<ListDataQualityJobDefinitionsError>,
    >;

    /// <p>Returns a list of devices in the fleet.</p>
    async fn list_device_fleets(
        &self,
        input: ListDeviceFleetsRequest,
    ) -> Result<ListDeviceFleetsResponse, RusotoError<ListDeviceFleetsError>>;

    /// <p>A list of devices.</p>
    async fn list_devices(
        &self,
        input: ListDevicesRequest,
    ) -> Result<ListDevicesResponse, RusotoError<ListDevicesError>>;

    /// <p>Lists the domains.</p>
    async fn list_domains(
        &self,
        input: ListDomainsRequest,
    ) -> Result<ListDomainsResponse, RusotoError<ListDomainsError>>;

    /// <p>Returns a list of edge packaging jobs.</p>
    async fn list_edge_packaging_jobs(
        &self,
        input: ListEdgePackagingJobsRequest,
    ) -> Result<ListEdgePackagingJobsResponse, RusotoError<ListEdgePackagingJobsError>>;

    /// <p>Lists endpoint configurations.</p>
    async fn list_endpoint_configs(
        &self,
        input: ListEndpointConfigsInput,
    ) -> Result<ListEndpointConfigsOutput, RusotoError<ListEndpointConfigsError>>;

    /// <p>Lists endpoints.</p>
    async fn list_endpoints(
        &self,
        input: ListEndpointsInput,
    ) -> Result<ListEndpointsOutput, RusotoError<ListEndpointsError>>;

    /// <p>Lists all the experiments in your account. The list can be filtered to show only experiments that were created in a specific time range. The list can be sorted by experiment name or creation time.</p>
    async fn list_experiments(
        &self,
        input: ListExperimentsRequest,
    ) -> Result<ListExperimentsResponse, RusotoError<ListExperimentsError>>;

    /// <p>List <code>FeatureGroup</code>s based on given filter and order.</p>
    async fn list_feature_groups(
        &self,
        input: ListFeatureGroupsRequest,
    ) -> Result<ListFeatureGroupsResponse, RusotoError<ListFeatureGroupsError>>;

    /// <p>Returns information about the flow definitions in your account.</p>
    async fn list_flow_definitions(
        &self,
        input: ListFlowDefinitionsRequest,
    ) -> Result<ListFlowDefinitionsResponse, RusotoError<ListFlowDefinitionsError>>;

    /// <p>Returns information about the human task user interfaces in your account.</p>
    async fn list_human_task_uis(
        &self,
        input: ListHumanTaskUisRequest,
    ) -> Result<ListHumanTaskUisResponse, RusotoError<ListHumanTaskUisError>>;

    /// <p>Gets a list of <a>HyperParameterTuningJobSummary</a> objects that describe the hyperparameter tuning jobs launched in your account.</p>
    async fn list_hyper_parameter_tuning_jobs(
        &self,
        input: ListHyperParameterTuningJobsRequest,
    ) -> Result<ListHyperParameterTuningJobsResponse, RusotoError<ListHyperParameterTuningJobsError>>;

    /// <p>Lists the versions of a specified image and their properties. The list can be filtered by creation time or modified time.</p>
    async fn list_image_versions(
        &self,
        input: ListImageVersionsRequest,
    ) -> Result<ListImageVersionsResponse, RusotoError<ListImageVersionsError>>;

    /// <p>Lists the images in your account and their properties. The list can be filtered by creation time or modified time, and whether the image name contains a specified string.</p>
    async fn list_images(
        &self,
        input: ListImagesRequest,
    ) -> Result<ListImagesResponse, RusotoError<ListImagesError>>;

    /// <p>Gets a list of labeling jobs.</p>
    async fn list_labeling_jobs(
        &self,
        input: ListLabelingJobsRequest,
    ) -> Result<ListLabelingJobsResponse, RusotoError<ListLabelingJobsError>>;

    /// <p>Gets a list of labeling jobs assigned to a specified work team.</p>
    async fn list_labeling_jobs_for_workteam(
        &self,
        input: ListLabelingJobsForWorkteamRequest,
    ) -> Result<ListLabelingJobsForWorkteamResponse, RusotoError<ListLabelingJobsForWorkteamError>>;

    /// <p>Lists model bias jobs definitions that satisfy various filters.</p>
    async fn list_model_bias_job_definitions(
        &self,
        input: ListModelBiasJobDefinitionsRequest,
    ) -> Result<ListModelBiasJobDefinitionsResponse, RusotoError<ListModelBiasJobDefinitionsError>>;

    /// <p>Lists model explainability job definitions that satisfy various filters.</p>
    async fn list_model_explainability_job_definitions(
        &self,
        input: ListModelExplainabilityJobDefinitionsRequest,
    ) -> Result<
        ListModelExplainabilityJobDefinitionsResponse,
        RusotoError<ListModelExplainabilityJobDefinitionsError>,
    >;

    /// <p>Gets a list of the model groups in your AWS account.</p>
    async fn list_model_package_groups(
        &self,
        input: ListModelPackageGroupsInput,
    ) -> Result<ListModelPackageGroupsOutput, RusotoError<ListModelPackageGroupsError>>;

    /// <p>Lists the model packages that have been created.</p>
    async fn list_model_packages(
        &self,
        input: ListModelPackagesInput,
    ) -> Result<ListModelPackagesOutput, RusotoError<ListModelPackagesError>>;

    /// <p>Gets a list of model quality monitoring job definitions in your account.</p>
    async fn list_model_quality_job_definitions(
        &self,
        input: ListModelQualityJobDefinitionsRequest,
    ) -> Result<
        ListModelQualityJobDefinitionsResponse,
        RusotoError<ListModelQualityJobDefinitionsError>,
    >;

    /// <p>Lists models created with the <a>CreateModel</a> API.</p>
    async fn list_models(
        &self,
        input: ListModelsInput,
    ) -> Result<ListModelsOutput, RusotoError<ListModelsError>>;

    /// <p>Returns list of all monitoring job executions.</p>
    async fn list_monitoring_executions(
        &self,
        input: ListMonitoringExecutionsRequest,
    ) -> Result<ListMonitoringExecutionsResponse, RusotoError<ListMonitoringExecutionsError>>;

    /// <p>Returns list of all monitoring schedules.</p>
    async fn list_monitoring_schedules(
        &self,
        input: ListMonitoringSchedulesRequest,
    ) -> Result<ListMonitoringSchedulesResponse, RusotoError<ListMonitoringSchedulesError>>;

    /// <p>Lists notebook instance lifestyle configurations created with the <a>CreateNotebookInstanceLifecycleConfig</a> API.</p>
    async fn list_notebook_instance_lifecycle_configs(
        &self,
        input: ListNotebookInstanceLifecycleConfigsInput,
    ) -> Result<
        ListNotebookInstanceLifecycleConfigsOutput,
        RusotoError<ListNotebookInstanceLifecycleConfigsError>,
    >;

    /// <p>Returns a list of the Amazon SageMaker notebook instances in the requester's account in an AWS Region. </p>
    async fn list_notebook_instances(
        &self,
        input: ListNotebookInstancesInput,
    ) -> Result<ListNotebookInstancesOutput, RusotoError<ListNotebookInstancesError>>;

    /// <p>Gets a list of <code>PipeLineExecutionStep</code> objects.</p>
    async fn list_pipeline_execution_steps(
        &self,
        input: ListPipelineExecutionStepsRequest,
    ) -> Result<ListPipelineExecutionStepsResponse, RusotoError<ListPipelineExecutionStepsError>>;

    /// <p>Gets a list of the pipeline executions.</p>
    async fn list_pipeline_executions(
        &self,
        input: ListPipelineExecutionsRequest,
    ) -> Result<ListPipelineExecutionsResponse, RusotoError<ListPipelineExecutionsError>>;

    /// <p>Gets a list of parameters for a pipeline execution.</p>
    async fn list_pipeline_parameters_for_execution(
        &self,
        input: ListPipelineParametersForExecutionRequest,
    ) -> Result<
        ListPipelineParametersForExecutionResponse,
        RusotoError<ListPipelineParametersForExecutionError>,
    >;

    /// <p>Gets a list of pipelines.</p>
    async fn list_pipelines(
        &self,
        input: ListPipelinesRequest,
    ) -> Result<ListPipelinesResponse, RusotoError<ListPipelinesError>>;

    /// <p>Lists processing jobs that satisfy various filters.</p>
    async fn list_processing_jobs(
        &self,
        input: ListProcessingJobsRequest,
    ) -> Result<ListProcessingJobsResponse, RusotoError<ListProcessingJobsError>>;

    /// <p>Gets a list of the projects in an AWS account.</p>
    async fn list_projects(
        &self,
        input: ListProjectsInput,
    ) -> Result<ListProjectsOutput, RusotoError<ListProjectsError>>;

    /// <p>Gets a list of the work teams that you are subscribed to in the AWS Marketplace. The list may be empty if no work team satisfies the filter specified in the <code>NameContains</code> parameter.</p>
    async fn list_subscribed_workteams(
        &self,
        input: ListSubscribedWorkteamsRequest,
    ) -> Result<ListSubscribedWorkteamsResponse, RusotoError<ListSubscribedWorkteamsError>>;

    /// <p>Returns the tags for the specified Amazon SageMaker resource.</p>
    async fn list_tags(
        &self,
        input: ListTagsInput,
    ) -> Result<ListTagsOutput, RusotoError<ListTagsError>>;

    /// <p>Lists training jobs.</p>
    async fn list_training_jobs(
        &self,
        input: ListTrainingJobsRequest,
    ) -> Result<ListTrainingJobsResponse, RusotoError<ListTrainingJobsError>>;

    /// <p>Gets a list of <a>TrainingJobSummary</a> objects that describe the training jobs that a hyperparameter tuning job launched.</p>
    async fn list_training_jobs_for_hyper_parameter_tuning_job(
        &self,
        input: ListTrainingJobsForHyperParameterTuningJobRequest,
    ) -> Result<
        ListTrainingJobsForHyperParameterTuningJobResponse,
        RusotoError<ListTrainingJobsForHyperParameterTuningJobError>,
    >;

    /// <p>Lists transform jobs.</p>
    async fn list_transform_jobs(
        &self,
        input: ListTransformJobsRequest,
    ) -> Result<ListTransformJobsResponse, RusotoError<ListTransformJobsError>>;

    /// <p><p>Lists the trial components in your account. You can sort the list by trial component name or creation time. You can filter the list to show only components that were created in a specific time range. You can also filter on one of the following:</p> <ul> <li> <p> <code>ExperimentName</code> </p> </li> <li> <p> <code>SourceArn</code> </p> </li> <li> <p> <code>TrialName</code> </p> </li> </ul></p>
    async fn list_trial_components(
        &self,
        input: ListTrialComponentsRequest,
    ) -> Result<ListTrialComponentsResponse, RusotoError<ListTrialComponentsError>>;

    /// <p>Lists the trials in your account. Specify an experiment name to limit the list to the trials that are part of that experiment. Specify a trial component name to limit the list to the trials that associated with that trial component. The list can be filtered to show only trials that were created in a specific time range. The list can be sorted by trial name or creation time.</p>
    async fn list_trials(
        &self,
        input: ListTrialsRequest,
    ) -> Result<ListTrialsResponse, RusotoError<ListTrialsError>>;

    /// <p>Lists user profiles.</p>
    async fn list_user_profiles(
        &self,
        input: ListUserProfilesRequest,
    ) -> Result<ListUserProfilesResponse, RusotoError<ListUserProfilesError>>;

    /// <p>Use this operation to list all private and vendor workforces in an AWS Region. Note that you can only have one private workforce per AWS Region.</p>
    async fn list_workforces(
        &self,
        input: ListWorkforcesRequest,
    ) -> Result<ListWorkforcesResponse, RusotoError<ListWorkforcesError>>;

    /// <p>Gets a list of private work teams that you have defined in a region. The list may be empty if no work team satisfies the filter specified in the <code>NameContains</code> parameter.</p>
    async fn list_workteams(
        &self,
        input: ListWorkteamsRequest,
    ) -> Result<ListWorkteamsResponse, RusotoError<ListWorkteamsError>>;

    /// <p>Adds a resouce policy to control access to a model group. For information about resoure policies, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html">Identity-based policies and resource-based policies</a> in the <i>AWS Identity and Access Management User Guide.</i>.</p>
    async fn put_model_package_group_policy(
        &self,
        input: PutModelPackageGroupPolicyInput,
    ) -> Result<PutModelPackageGroupPolicyOutput, RusotoError<PutModelPackageGroupPolicyError>>;

    /// <p>Register devices.</p>
    async fn register_devices(
        &self,
        input: RegisterDevicesRequest,
    ) -> Result<(), RusotoError<RegisterDevicesError>>;

    /// <p>Renders the UI template so that you can preview the worker's experience. </p>
    async fn render_ui_template(
        &self,
        input: RenderUiTemplateRequest,
    ) -> Result<RenderUiTemplateResponse, RusotoError<RenderUiTemplateError>>;

    /// <p>Finds Amazon SageMaker resources that match a search query. Matching resources are returned as a list of <code>SearchRecord</code> objects in the response. You can sort the search results by any resource property in a ascending or descending order.</p> <p>You can query against the following value types: numeric, text, Boolean, and timestamp.</p>
    async fn search(
        &self,
        input: SearchRequest,
    ) -> Result<SearchResponse, RusotoError<SearchError>>;

    /// <p><p>Starts a previously stopped monitoring schedule.</p> <note> <p>By default, when you successfully create a new schedule, the status of a monitoring schedule is <code>scheduled</code>.</p> </note></p>
    async fn start_monitoring_schedule(
        &self,
        input: StartMonitoringScheduleRequest,
    ) -> Result<(), RusotoError<StartMonitoringScheduleError>>;

    /// <p>Launches an ML compute instance with the latest version of the libraries and attaches your ML storage volume. After configuring the notebook instance, Amazon SageMaker sets the notebook instance status to <code>InService</code>. A notebook instance's status must be <code>InService</code> before you can connect to your Jupyter notebook. </p>
    async fn start_notebook_instance(
        &self,
        input: StartNotebookInstanceInput,
    ) -> Result<(), RusotoError<StartNotebookInstanceError>>;

    /// <p>Starts a pipeline execution.</p>
    async fn start_pipeline_execution(
        &self,
        input: StartPipelineExecutionRequest,
    ) -> Result<StartPipelineExecutionResponse, RusotoError<StartPipelineExecutionError>>;

    /// <p>A method for forcing the termination of a running job.</p>
    async fn stop_auto_ml_job(
        &self,
        input: StopAutoMLJobRequest,
    ) -> Result<(), RusotoError<StopAutoMLJobError>>;

    /// <p>Stops a model compilation job.</p> <p> To stop a job, Amazon SageMaker sends the algorithm the SIGTERM signal. This gracefully shuts the job down. If the job hasn't stopped, it sends the SIGKILL signal.</p> <p>When it receives a <code>StopCompilationJob</code> request, Amazon SageMaker changes the <a>CompilationJobSummary$CompilationJobStatus</a> of the job to <code>Stopping</code>. After Amazon SageMaker stops the job, it sets the <a>CompilationJobSummary$CompilationJobStatus</a> to <code>Stopped</code>. </p>
    async fn stop_compilation_job(
        &self,
        input: StopCompilationJobRequest,
    ) -> Result<(), RusotoError<StopCompilationJobError>>;

    /// <p>Request to stop an edge packaging job.</p>
    async fn stop_edge_packaging_job(
        &self,
        input: StopEdgePackagingJobRequest,
    ) -> Result<(), RusotoError<StopEdgePackagingJobError>>;

    /// <p>Stops a running hyperparameter tuning job and all running training jobs that the tuning job launched.</p> <p>All model artifacts output from the training jobs are stored in Amazon Simple Storage Service (Amazon S3). All data that the training jobs write to Amazon CloudWatch Logs are still available in CloudWatch. After the tuning job moves to the <code>Stopped</code> state, it releases all reserved resources for the tuning job.</p>
    async fn stop_hyper_parameter_tuning_job(
        &self,
        input: StopHyperParameterTuningJobRequest,
    ) -> Result<(), RusotoError<StopHyperParameterTuningJobError>>;

    /// <p>Stops a running labeling job. A job that is stopped cannot be restarted. Any results obtained before the job is stopped are placed in the Amazon S3 output bucket.</p>
    async fn stop_labeling_job(
        &self,
        input: StopLabelingJobRequest,
    ) -> Result<(), RusotoError<StopLabelingJobError>>;

    /// <p>Stops a previously started monitoring schedule.</p>
    async fn stop_monitoring_schedule(
        &self,
        input: StopMonitoringScheduleRequest,
    ) -> Result<(), RusotoError<StopMonitoringScheduleError>>;

    /// <p>Terminates the ML compute instance. Before terminating the instance, Amazon SageMaker disconnects the ML storage volume from it. Amazon SageMaker preserves the ML storage volume. Amazon SageMaker stops charging you for the ML compute instance when you call <code>StopNotebookInstance</code>.</p> <p>To access data on the ML storage volume for a notebook instance that has been terminated, call the <code>StartNotebookInstance</code> API. <code>StartNotebookInstance</code> launches another ML compute instance, configures it, and attaches the preserved ML storage volume so you can continue your work. </p>
    async fn stop_notebook_instance(
        &self,
        input: StopNotebookInstanceInput,
    ) -> Result<(), RusotoError<StopNotebookInstanceError>>;

    /// <p>Stops a pipeline execution.</p>
    async fn stop_pipeline_execution(
        &self,
        input: StopPipelineExecutionRequest,
    ) -> Result<StopPipelineExecutionResponse, RusotoError<StopPipelineExecutionError>>;

    /// <p>Stops a processing job.</p>
    async fn stop_processing_job(
        &self,
        input: StopProcessingJobRequest,
    ) -> Result<(), RusotoError<StopProcessingJobError>>;

    /// <p>Stops a training job. To stop a job, Amazon SageMaker sends the algorithm the <code>SIGTERM</code> signal, which delays job termination for 120 seconds. Algorithms might use this 120-second window to save the model artifacts, so the results of the training is not lost. </p> <p>When it receives a <code>StopTrainingJob</code> request, Amazon SageMaker changes the status of the job to <code>Stopping</code>. After Amazon SageMaker stops the job, it sets the status to <code>Stopped</code>.</p>
    async fn stop_training_job(
        &self,
        input: StopTrainingJobRequest,
    ) -> Result<(), RusotoError<StopTrainingJobError>>;

    /// <p>Stops a transform job.</p> <p>When Amazon SageMaker receives a <code>StopTransformJob</code> request, the status of the job changes to <code>Stopping</code>. After Amazon SageMaker stops the job, the status is set to <code>Stopped</code>. When you stop a transform job before it is completed, Amazon SageMaker doesn't store the job's output in Amazon S3.</p>
    async fn stop_transform_job(
        &self,
        input: StopTransformJobRequest,
    ) -> Result<(), RusotoError<StopTransformJobError>>;

    /// <p>Updates an action.</p>
    async fn update_action(
        &self,
        input: UpdateActionRequest,
    ) -> Result<UpdateActionResponse, RusotoError<UpdateActionError>>;

    /// <p>Updates the properties of an AppImageConfig.</p>
    async fn update_app_image_config(
        &self,
        input: UpdateAppImageConfigRequest,
    ) -> Result<UpdateAppImageConfigResponse, RusotoError<UpdateAppImageConfigError>>;

    /// <p>Updates an artifact.</p>
    async fn update_artifact(
        &self,
        input: UpdateArtifactRequest,
    ) -> Result<UpdateArtifactResponse, RusotoError<UpdateArtifactError>>;

    /// <p>Updates the specified Git repository with the specified values.</p>
    async fn update_code_repository(
        &self,
        input: UpdateCodeRepositoryInput,
    ) -> Result<UpdateCodeRepositoryOutput, RusotoError<UpdateCodeRepositoryError>>;

    /// <p>Updates a context.</p>
    async fn update_context(
        &self,
        input: UpdateContextRequest,
    ) -> Result<UpdateContextResponse, RusotoError<UpdateContextError>>;

    /// <p>Updates a fleet of devices.</p>
    async fn update_device_fleet(
        &self,
        input: UpdateDeviceFleetRequest,
    ) -> Result<(), RusotoError<UpdateDeviceFleetError>>;

    /// <p>Updates one or more devices in a fleet.</p>
    async fn update_devices(
        &self,
        input: UpdateDevicesRequest,
    ) -> Result<(), RusotoError<UpdateDevicesError>>;

    /// <p>Updates the default settings for new user profiles in the domain.</p>
    async fn update_domain(
        &self,
        input: UpdateDomainRequest,
    ) -> Result<UpdateDomainResponse, RusotoError<UpdateDomainError>>;

    /// <p><p>Deploys the new <code>EndpointConfig</code> specified in the request, switches to using newly created endpoint, and then deletes resources provisioned for the endpoint using the previous <code>EndpointConfig</code> (there is no availability loss). </p> <p>When Amazon SageMaker receives the request, it sets the endpoint status to <code>Updating</code>. After updating the endpoint, it sets the status to <code>InService</code>. To check the status of an endpoint, use the <a>DescribeEndpoint</a> API. </p> <note> <p>You must not delete an <code>EndpointConfig</code> in use by an endpoint that is live or while the <code>UpdateEndpoint</code> or <code>CreateEndpoint</code> operations are being performed on the endpoint. To update an endpoint, you must create a new <code>EndpointConfig</code>.</p> <p>If you delete the <code>EndpointConfig</code> of an endpoint that is active or being created or updated you may lose visibility into the instance type the endpoint is using. The endpoint must be deleted in order to stop incurring charges.</p> </note></p>
    async fn update_endpoint(
        &self,
        input: UpdateEndpointInput,
    ) -> Result<UpdateEndpointOutput, RusotoError<UpdateEndpointError>>;

    /// <p>Updates variant weight of one or more variants associated with an existing endpoint, or capacity of one variant associated with an existing endpoint. When it receives the request, Amazon SageMaker sets the endpoint status to <code>Updating</code>. After updating the endpoint, it sets the status to <code>InService</code>. To check the status of an endpoint, use the <a>DescribeEndpoint</a> API. </p>
    async fn update_endpoint_weights_and_capacities(
        &self,
        input: UpdateEndpointWeightsAndCapacitiesInput,
    ) -> Result<
        UpdateEndpointWeightsAndCapacitiesOutput,
        RusotoError<UpdateEndpointWeightsAndCapacitiesError>,
    >;

    /// <p>Adds, updates, or removes the description of an experiment. Updates the display name of an experiment.</p>
    async fn update_experiment(
        &self,
        input: UpdateExperimentRequest,
    ) -> Result<UpdateExperimentResponse, RusotoError<UpdateExperimentError>>;

    /// <p>Updates the properties of a SageMaker image. To change the image's tags, use the <a>AddTags</a> and <a>DeleteTags</a> APIs.</p>
    async fn update_image(
        &self,
        input: UpdateImageRequest,
    ) -> Result<UpdateImageResponse, RusotoError<UpdateImageError>>;

    /// <p>Updates a versioned model.</p>
    async fn update_model_package(
        &self,
        input: UpdateModelPackageInput,
    ) -> Result<UpdateModelPackageOutput, RusotoError<UpdateModelPackageError>>;

    /// <p>Updates a previously created schedule.</p>
    async fn update_monitoring_schedule(
        &self,
        input: UpdateMonitoringScheduleRequest,
    ) -> Result<UpdateMonitoringScheduleResponse, RusotoError<UpdateMonitoringScheduleError>>;

    /// <p>Updates a notebook instance. NotebookInstance updates include upgrading or downgrading the ML compute instance used for your notebook instance to accommodate changes in your workload requirements.</p>
    async fn update_notebook_instance(
        &self,
        input: UpdateNotebookInstanceInput,
    ) -> Result<UpdateNotebookInstanceOutput, RusotoError<UpdateNotebookInstanceError>>;

    /// <p>Updates a notebook instance lifecycle configuration created with the <a>CreateNotebookInstanceLifecycleConfig</a> API.</p>
    async fn update_notebook_instance_lifecycle_config(
        &self,
        input: UpdateNotebookInstanceLifecycleConfigInput,
    ) -> Result<
        UpdateNotebookInstanceLifecycleConfigOutput,
        RusotoError<UpdateNotebookInstanceLifecycleConfigError>,
    >;

    /// <p>Updates a pipeline.</p>
    async fn update_pipeline(
        &self,
        input: UpdatePipelineRequest,
    ) -> Result<UpdatePipelineResponse, RusotoError<UpdatePipelineError>>;

    /// <p>Updates a pipeline execution.</p>
    async fn update_pipeline_execution(
        &self,
        input: UpdatePipelineExecutionRequest,
    ) -> Result<UpdatePipelineExecutionResponse, RusotoError<UpdatePipelineExecutionError>>;

    /// <p>Update a model training job to request a new Debugger profiling configuration.</p>
    async fn update_training_job(
        &self,
        input: UpdateTrainingJobRequest,
    ) -> Result<UpdateTrainingJobResponse, RusotoError<UpdateTrainingJobError>>;

    /// <p>Updates the display name of a trial.</p>
    async fn update_trial(
        &self,
        input: UpdateTrialRequest,
    ) -> Result<UpdateTrialResponse, RusotoError<UpdateTrialError>>;

    /// <p>Updates one or more properties of a trial component.</p>
    async fn update_trial_component(
        &self,
        input: UpdateTrialComponentRequest,
    ) -> Result<UpdateTrialComponentResponse, RusotoError<UpdateTrialComponentError>>;

    /// <p>Updates a user profile.</p>
    async fn update_user_profile(
        &self,
        input: UpdateUserProfileRequest,
    ) -> Result<UpdateUserProfileResponse, RusotoError<UpdateUserProfileError>>;

    /// <p><p>Use this operation to update your workforce. You can use this operation to require that workers use specific IP addresses to work on tasks and to update your OpenID Connect (OIDC) Identity Provider (IdP) workforce configuration.</p> <p> Use <code>SourceIpConfig</code> to restrict worker access to tasks to a specific range of IP addresses. You specify allowed IP addresses by creating a list of up to ten <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html">CIDRs</a>. By default, a workforce isn&#39;t restricted to specific IP addresses. If you specify a range of IP addresses, workers who attempt to access tasks using any IP address outside the specified range are denied and get a <code>Not Found</code> error message on the worker portal.</p> <p>Use <code>OidcConfig</code> to update the configuration of a workforce created using your own OIDC IdP. </p> <important> <p>You can only update your OIDC IdP configuration when there are no work teams associated with your workforce. You can delete work teams using the operation.</p> </important> <p>After restricting access to a range of IP addresses or updating your OIDC IdP configuration with this operation, you can view details about your update workforce using the operation.</p> <important> <p>This operation only applies to private workforces.</p> </important></p>
    async fn update_workforce(
        &self,
        input: UpdateWorkforceRequest,
    ) -> Result<UpdateWorkforceResponse, RusotoError<UpdateWorkforceError>>;

    /// <p>Updates an existing work team with new member definitions or description.</p>
    async fn update_workteam(
        &self,
        input: UpdateWorkteamRequest,
    ) -> Result<UpdateWorkteamResponse, RusotoError<UpdateWorkteamError>>;
}
/// A client for the SageMaker API.
#[derive(Clone)]
pub struct SageMakerClient {
    client: Client,
    region: region::Region,
}

impl SageMakerClient {
    /// Creates a client backed by the default tokio event loop.
    ///
    /// The client will use the default credentials provider and tls client.
    pub fn new(region: region::Region) -> SageMakerClient {
        SageMakerClient {
            client: Client::shared(),
            region,
        }
    }

    pub fn new_with<P, D>(
        request_dispatcher: D,
        credentials_provider: P,
        region: region::Region,
    ) -> SageMakerClient
    where
        P: ProvideAwsCredentials + Send + Sync + 'static,
        D: DispatchSignedRequest + Send + Sync + 'static,
    {
        SageMakerClient {
            client: Client::new_with(credentials_provider, request_dispatcher),
            region,
        }
    }

    pub fn new_with_client(client: Client, region: region::Region) -> SageMakerClient {
        SageMakerClient { client, region }
    }
}

#[async_trait]
impl SageMaker for SageMakerClient {
    /// <p>Creates an <i>association</i> between the source and the destination. A source can be associated with multiple destinations, and a destination can be associated with multiple sources. An association is a lineage tracking entity. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/lineage-tracking.html">Amazon SageMaker ML Lineage Tracking</a>.</p>
    async fn add_association(
        &self,
        input: AddAssociationRequest,
    ) -> Result<AddAssociationResponse, RusotoError<AddAssociationError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.AddAssociation");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, AddAssociationError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<AddAssociationResponse, _>()
    }

    /// <p><p>Adds or overwrites one or more tags for the specified Amazon SageMaker resource. You can add tags to notebook instances, training jobs, hyperparameter tuning jobs, batch transform jobs, models, labeling jobs, work teams, endpoint configurations, and endpoints.</p> <p>Each tag consists of a key and an optional value. Tag keys must be unique per resource. For more information about tags, see For more information, see <a href="https://aws.amazon.com/answers/account-management/aws-tagging-strategies/">AWS Tagging Strategies</a>.</p> <note> <p>Tags that you add to a hyperparameter tuning job by calling this API are also added to any training jobs that the hyperparameter tuning job launches after you call this API, but not to training jobs that the hyperparameter tuning job launched before you called this API. To make sure that the tags associated with a hyperparameter tuning job are also added to all training jobs that the hyperparameter tuning job launches, add the tags when you first create the tuning job by specifying them in the <code>Tags</code> parameter of <a>CreateHyperParameterTuningJob</a> </p> </note></p>
    async fn add_tags(
        &self,
        input: AddTagsInput,
    ) -> Result<AddTagsOutput, RusotoError<AddTagsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.AddTags");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, AddTagsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<AddTagsOutput, _>()
    }

    /// <p>Associates a trial component with a trial. A trial component can be associated with multiple trials. To disassociate a trial component from a trial, call the <a>DisassociateTrialComponent</a> API.</p>
    async fn associate_trial_component(
        &self,
        input: AssociateTrialComponentRequest,
    ) -> Result<AssociateTrialComponentResponse, RusotoError<AssociateTrialComponentError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.AssociateTrialComponent");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, AssociateTrialComponentError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<AssociateTrialComponentResponse, _>()
    }

    /// <p>Creates an <i>action</i>. An action is a lineage tracking entity that represents an action or activity. For example, a model deployment or an HPO job. Generally, an action involves at least one input or output artifact. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/lineage-tracking.html">Amazon SageMaker ML Lineage Tracking</a>.</p>
    async fn create_action(
        &self,
        input: CreateActionRequest,
    ) -> Result<CreateActionResponse, RusotoError<CreateActionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateAction");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateActionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateActionResponse, _>()
    }

    /// <p>Create a machine learning algorithm that you can use in Amazon SageMaker and list in the AWS Marketplace.</p>
    async fn create_algorithm(
        &self,
        input: CreateAlgorithmInput,
    ) -> Result<CreateAlgorithmOutput, RusotoError<CreateAlgorithmError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateAlgorithm");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateAlgorithmError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateAlgorithmOutput, _>()
    }

    /// <p>Creates a running App for the specified UserProfile. Supported Apps are JupyterServer and KernelGateway. This operation is automatically invoked by Amazon SageMaker Studio upon access to the associated Domain, and when new kernel configurations are selected by the user. A user may have multiple Apps active simultaneously.</p>
    async fn create_app(
        &self,
        input: CreateAppRequest,
    ) -> Result<CreateAppResponse, RusotoError<CreateAppError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateApp");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateAppError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateAppResponse, _>()
    }

    /// <p>Creates a configuration for running a SageMaker image as a KernelGateway app. The configuration specifies the Amazon Elastic File System (EFS) storage volume on the image, and a list of the kernels in the image.</p>
    async fn create_app_image_config(
        &self,
        input: CreateAppImageConfigRequest,
    ) -> Result<CreateAppImageConfigResponse, RusotoError<CreateAppImageConfigError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateAppImageConfig");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateAppImageConfigError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<CreateAppImageConfigResponse, _>()
    }

    /// <p>Creates an <i>artifact</i>. An artifact is a lineage tracking entity that represents a URI addressable object or data. Some examples are the S3 URI of a dataset and the ECR registry path of an image. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/lineage-tracking.html">Amazon SageMaker ML Lineage Tracking</a>.</p>
    async fn create_artifact(
        &self,
        input: CreateArtifactRequest,
    ) -> Result<CreateArtifactResponse, RusotoError<CreateArtifactError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateArtifact");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateArtifactError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateArtifactResponse, _>()
    }

    /// <p>Creates an Autopilot job.</p> <p>Find the best performing model after you run an Autopilot job by calling . Deploy that model by following the steps described in <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/ex1-deploy-model.html">Step 6.1: Deploy the Model to Amazon SageMaker Hosting Services</a>.</p> <p>For information about how to use Autopilot, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development.html"> Automate Model Development with Amazon SageMaker Autopilot</a>.</p>
    async fn create_auto_ml_job(
        &self,
        input: CreateAutoMLJobRequest,
    ) -> Result<CreateAutoMLJobResponse, RusotoError<CreateAutoMLJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateAutoMLJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateAutoMLJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateAutoMLJobResponse, _>()
    }

    /// <p>Creates a Git repository as a resource in your Amazon SageMaker account. You can associate the repository with notebook instances so that you can use Git source control for the notebooks you create. The Git repository is a resource in your Amazon SageMaker account, so it can be associated with more than one notebook instance, and it persists independently from the lifecycle of any notebook instances it is associated with.</p> <p>The repository can be hosted either in <a href="https://docs.aws.amazon.com/codecommit/latest/userguide/welcome.html">AWS CodeCommit</a> or in any other Git repository.</p>
    async fn create_code_repository(
        &self,
        input: CreateCodeRepositoryInput,
    ) -> Result<CreateCodeRepositoryOutput, RusotoError<CreateCodeRepositoryError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateCodeRepository");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateCodeRepositoryError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateCodeRepositoryOutput, _>()
    }

    /// <p>Starts a model compilation job. After the model has been compiled, Amazon SageMaker saves the resulting model artifacts to an Amazon Simple Storage Service (Amazon S3) bucket that you specify. </p> <p>If you choose to host your model using Amazon SageMaker hosting services, you can use the resulting model artifacts as part of the model. You can also use the artifacts with AWS IoT Greengrass. In that case, deploy them as an ML resource.</p> <p>In the request body, you provide the following:</p> <ul> <li> <p>A name for the compilation job</p> </li> <li> <p> Information about the input model artifacts </p> </li> <li> <p>The output location for the compiled model and the device (target) that the model runs on </p> </li> <li> <p>The Amazon Resource Name (ARN) of the IAM role that Amazon SageMaker assumes to perform the model compilation job. </p> </li> </ul> <p>You can also provide a <code>Tag</code> to track the model compilation job's resource use and costs. The response body contains the <code>CompilationJobArn</code> for the compiled job.</p> <p>To stop a model compilation job, use <a>StopCompilationJob</a>. To get information about a particular model compilation job, use <a>DescribeCompilationJob</a>. To get information about multiple model compilation jobs, use <a>ListCompilationJobs</a>.</p>
    async fn create_compilation_job(
        &self,
        input: CreateCompilationJobRequest,
    ) -> Result<CreateCompilationJobResponse, RusotoError<CreateCompilationJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateCompilationJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateCompilationJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<CreateCompilationJobResponse, _>()
    }

    /// <p>Creates a <i>context</i>. A context is a lineage tracking entity that represents a logical grouping of other tracking or experiment entities. Some examples are an endpoint and a model package. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/lineage-tracking.html">Amazon SageMaker ML Lineage Tracking</a>.</p>
    async fn create_context(
        &self,
        input: CreateContextRequest,
    ) -> Result<CreateContextResponse, RusotoError<CreateContextError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateContext");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateContextError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateContextResponse, _>()
    }

    /// <p>Creates a definition for a job that monitors data quality and drift. For information about model monitor, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor.html">Amazon SageMaker Model Monitor</a>.</p>
    async fn create_data_quality_job_definition(
        &self,
        input: CreateDataQualityJobDefinitionRequest,
    ) -> Result<
        CreateDataQualityJobDefinitionResponse,
        RusotoError<CreateDataQualityJobDefinitionError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateDataQualityJobDefinition");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateDataQualityJobDefinitionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<CreateDataQualityJobDefinitionResponse, _>()
    }

    /// <p>Creates a device fleet.</p>
    async fn create_device_fleet(
        &self,
        input: CreateDeviceFleetRequest,
    ) -> Result<(), RusotoError<CreateDeviceFleetError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateDeviceFleet");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateDeviceFleetError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Creates a <code>Domain</code> used by Amazon SageMaker Studio. A domain consists of an associated Amazon Elastic File System (EFS) volume, a list of authorized users, and a variety of security, application, policy, and Amazon Virtual Private Cloud (VPC) configurations. An AWS account is limited to one domain per region. Users within a domain can share notebook files and other artifacts with each other.</p> <p> <b>EFS storage</b> </p> <p>When a domain is created, an EFS volume is created for use by all of the users within the domain. Each user receives a private home directory within the EFS volume for notebooks, Git repositories, and data files.</p> <p>SageMaker uses the AWS Key Management Service (AWS KMS) to encrypt the EFS volume attached to the domain with an AWS managed customer master key (CMK) by default. For more control, you can specify a customer managed CMK. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/encryption-at-rest.html">Protect Data at Rest Using Encryption</a>.</p> <p> <b>VPC configuration</b> </p> <p>All SageMaker Studio traffic between the domain and the EFS volume is through the specified VPC and subnets. For other Studio traffic, you can specify the <code>AppNetworkAccessType</code> parameter. <code>AppNetworkAccessType</code> corresponds to the network access type that you choose when you onboard to Studio. The following options are available:</p> <ul> <li> <p> <code>PublicInternetOnly</code> - Non-EFS traffic goes through a VPC managed by Amazon SageMaker, which allows internet access. This is the default value.</p> </li> <li> <p> <code>VpcOnly</code> - All Studio traffic is through the specified VPC and subnets. Internet access is disabled by default. To allow internet access, you must specify a NAT gateway.</p> <p>When internet access is disabled, you won't be able to run a Studio notebook or to train or host models unless your VPC has an interface endpoint to the SageMaker API and runtime or a NAT gateway and your security groups allow outbound connections.</p> </li> </ul> <p>For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/studio-notebooks-and-internet-access.html">Connect SageMaker Studio Notebooks to Resources in a VPC</a>.</p>
    async fn create_domain(
        &self,
        input: CreateDomainRequest,
    ) -> Result<CreateDomainResponse, RusotoError<CreateDomainError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateDomain");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateDomainError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateDomainResponse, _>()
    }

    /// <p>Starts a SageMaker Edge Manager model packaging job. Edge Manager will use the model artifacts from the Amazon Simple Storage Service bucket that you specify. After the model has been packaged, Amazon SageMaker saves the resulting artifacts to an S3 bucket that you specify.</p>
    async fn create_edge_packaging_job(
        &self,
        input: CreateEdgePackagingJobRequest,
    ) -> Result<(), RusotoError<CreateEdgePackagingJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateEdgePackagingJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateEdgePackagingJobError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p><p>Creates an endpoint using the endpoint configuration specified in the request. Amazon SageMaker uses the endpoint to provision resources and deploy models. You create the endpoint configuration with the <a>CreateEndpointConfig</a> API. </p> <p> Use this API to deploy models using Amazon SageMaker hosting services. </p> <p>For an example that calls this method when deploying a model to Amazon SageMaker hosting services, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/ex1-deploy-model.html#ex1-deploy-model-boto">Deploy the Model to Amazon SageMaker Hosting Services (AWS SDK for Python (Boto 3)).</a> </p> <note> <p> You must not delete an <code>EndpointConfig</code> that is in use by an endpoint that is live or while the <code>UpdateEndpoint</code> or <code>CreateEndpoint</code> operations are being performed on the endpoint. To update an endpoint, you must create a new <code>EndpointConfig</code>.</p> </note> <p>The endpoint name must be unique within an AWS Region in your AWS account. </p> <p>When it receives the request, Amazon SageMaker creates the endpoint, launches the resources (ML compute instances), and deploys the model(s) on them. </p> <note> <p>When you call <a>CreateEndpoint</a>, a load call is made to DynamoDB to verify that your endpoint configuration exists. When you read data from a DynamoDB table supporting <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadConsistency.html"> <code>Eventually Consistent Reads</code> </a>, the response might not reflect the results of a recently completed write operation. The response might include some stale data. If the dependent entities are not yet in DynamoDB, this causes a validation error. If you repeat your read request after a short time, the response should return the latest data. So retry logic is recommended to handle these possible issues. We also recommend that customers call <a>DescribeEndpointConfig</a> before calling <a>CreateEndpoint</a> to minimize the potential impact of a DynamoDB eventually consistent read.</p> </note> <p>When Amazon SageMaker receives the request, it sets the endpoint status to <code>Creating</code>. After it creates the endpoint, it sets the status to <code>InService</code>. Amazon SageMaker can then process incoming requests for inferences. To check the status of an endpoint, use the <a>DescribeEndpoint</a> API.</p> <p>If any of the models hosted at this endpoint get model data from an Amazon S3 location, Amazon SageMaker uses AWS Security Token Service to download model artifacts from the S3 path you provided. AWS STS is activated in your IAM user account by default. If you previously deactivated AWS STS for a region, you need to reactivate AWS STS for that region. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html">Activating and Deactivating AWS STS in an AWS Region</a> in the <i>AWS Identity and Access Management User Guide</i>.</p> <note> <p> To add the IAM role policies for using this API operation, go to the <a href="https://console.aws.amazon.com/iam/">IAM console</a>, and choose Roles in the left navigation pane. Search the IAM role that you want to grant access to use the <a>CreateEndpoint</a> and <a>CreateEndpointConfig</a> API operations, add the following policies to the role. </p> <ul> <li> <p>Option 1: For a full Amazon SageMaker access, search and attach the <code>AmazonSageMakerFullAccess</code> policy.</p> </li> <li> <p>Option 2: For granting a limited access to an IAM role, paste the following Action elements manually into the JSON file of the IAM role: </p> <p> <code>&quot;Action&quot;: [&quot;sagemaker:CreateEndpoint&quot;, &quot;sagemaker:CreateEndpointConfig&quot;]</code> </p> <p> <code>&quot;Resource&quot;: [</code> </p> <p> <code>&quot;arn:aws:sagemaker:region:account-id:endpoint/endpointName&quot;</code> </p> <p> <code>&quot;arn:aws:sagemaker:region:account-id:endpoint-config/endpointConfigName&quot;</code> </p> <p> <code>]</code> </p> <p>For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/api-permissions-reference.html">Amazon SageMaker API Permissions: Actions, Permissions, and Resources Reference</a>.</p> </li> </ul> </note></p>
    async fn create_endpoint(
        &self,
        input: CreateEndpointInput,
    ) -> Result<CreateEndpointOutput, RusotoError<CreateEndpointError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateEndpoint");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateEndpointError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateEndpointOutput, _>()
    }

    /// <p><p>Creates an endpoint configuration that Amazon SageMaker hosting services uses to deploy models. In the configuration, you identify one or more models, created using the <code>CreateModel</code> API, to deploy and the resources that you want Amazon SageMaker to provision. Then you call the <a>CreateEndpoint</a> API.</p> <note> <p> Use this API if you want to use Amazon SageMaker hosting services to deploy models into production. </p> </note> <p>In the request, you define a <code>ProductionVariant</code>, for each model that you want to deploy. Each <code>ProductionVariant</code> parameter also describes the resources that you want Amazon SageMaker to provision. This includes the number and type of ML compute instances to deploy. </p> <p>If you are hosting multiple models, you also assign a <code>VariantWeight</code> to specify how much traffic you want to allocate to each model. For example, suppose that you want to host two models, A and B, and you assign traffic weight 2 for model A and 1 for model B. Amazon SageMaker distributes two-thirds of the traffic to Model A, and one-third to model B. </p> <p>For an example that calls this method when deploying a model to Amazon SageMaker hosting services, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/ex1-deploy-model.html#ex1-deploy-model-boto">Deploy the Model to Amazon SageMaker Hosting Services (AWS SDK for Python (Boto 3)).</a> </p> <note> <p>When you call <a>CreateEndpoint</a>, a load call is made to DynamoDB to verify that your endpoint configuration exists. When you read data from a DynamoDB table supporting <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadConsistency.html"> <code>Eventually Consistent Reads</code> </a>, the response might not reflect the results of a recently completed write operation. The response might include some stale data. If the dependent entities are not yet in DynamoDB, this causes a validation error. If you repeat your read request after a short time, the response should return the latest data. So retry logic is recommended to handle these possible issues. We also recommend that customers call <a>DescribeEndpointConfig</a> before calling <a>CreateEndpoint</a> to minimize the potential impact of a DynamoDB eventually consistent read.</p> </note></p>
    async fn create_endpoint_config(
        &self,
        input: CreateEndpointConfigInput,
    ) -> Result<CreateEndpointConfigOutput, RusotoError<CreateEndpointConfigError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateEndpointConfig");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateEndpointConfigError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateEndpointConfigOutput, _>()
    }

    /// <p>Creates an SageMaker <i>experiment</i>. An experiment is a collection of <i>trials</i> that are observed, compared and evaluated as a group. A trial is a set of steps, called <i>trial components</i>, that produce a machine learning model.</p> <p>The goal of an experiment is to determine the components that produce the best model. Multiple trials are performed, each one isolating and measuring the impact of a change to one or more inputs, while keeping the remaining inputs constant.</p> <p>When you use Amazon SageMaker Studio or the Amazon SageMaker Python SDK, all experiments, trials, and trial components are automatically tracked, logged, and indexed. When you use the AWS SDK for Python (Boto), you must use the logging APIs provided by the SDK.</p> <p>You can add tags to experiments, trials, trial components and then use the <a>Search</a> API to search for the tags.</p> <p>To add a description to an experiment, specify the optional <code>Description</code> parameter. To add a description later, or to change the description, call the <a>UpdateExperiment</a> API.</p> <p>To get a list of all your experiments, call the <a>ListExperiments</a> API. To view an experiment's properties, call the <a>DescribeExperiment</a> API. To get a list of all the trials associated with an experiment, call the <a>ListTrials</a> API. To create a trial call the <a>CreateTrial</a> API.</p>
    async fn create_experiment(
        &self,
        input: CreateExperimentRequest,
    ) -> Result<CreateExperimentResponse, RusotoError<CreateExperimentError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateExperiment");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateExperimentError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateExperimentResponse, _>()
    }

    /// <p><p>Create a new <code>FeatureGroup</code>. A <code>FeatureGroup</code> is a group of <code>Features</code> defined in the <code>FeatureStore</code> to describe a <code>Record</code>. </p> <p>The <code>FeatureGroup</code> defines the schema and features contained in the FeatureGroup. A <code>FeatureGroup</code> definition is composed of a list of <code>Features</code>, a <code>RecordIdentifierFeatureName</code>, an <code>EventTimeFeatureName</code> and configurations for its <code>OnlineStore</code> and <code>OfflineStore</code>. Check <a href="https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html">AWS service quotas</a> to see the <code>FeatureGroup</code>s quota for your AWS account.</p> <important> <p>You must include at least one of <code>OnlineStoreConfig</code> and <code>OfflineStoreConfig</code> to create a <code>FeatureGroup</code>.</p> </important></p>
    async fn create_feature_group(
        &self,
        input: CreateFeatureGroupRequest,
    ) -> Result<CreateFeatureGroupResponse, RusotoError<CreateFeatureGroupError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateFeatureGroup");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateFeatureGroupError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateFeatureGroupResponse, _>()
    }

    /// <p>Creates a flow definition.</p>
    async fn create_flow_definition(
        &self,
        input: CreateFlowDefinitionRequest,
    ) -> Result<CreateFlowDefinitionResponse, RusotoError<CreateFlowDefinitionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateFlowDefinition");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateFlowDefinitionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<CreateFlowDefinitionResponse, _>()
    }

    /// <p>Defines the settings you will use for the human review workflow user interface. Reviewers will see a three-panel interface with an instruction area, the item to review, and an input area.</p>
    async fn create_human_task_ui(
        &self,
        input: CreateHumanTaskUiRequest,
    ) -> Result<CreateHumanTaskUiResponse, RusotoError<CreateHumanTaskUiError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateHumanTaskUi");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateHumanTaskUiError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateHumanTaskUiResponse, _>()
    }

    /// <p>Starts a hyperparameter tuning job. A hyperparameter tuning job finds the best version of a model by running many training jobs on your dataset using the algorithm you choose and values for hyperparameters within ranges that you specify. It then chooses the hyperparameter values that result in a model that performs the best, as measured by an objective metric that you choose.</p>
    async fn create_hyper_parameter_tuning_job(
        &self,
        input: CreateHyperParameterTuningJobRequest,
    ) -> Result<
        CreateHyperParameterTuningJobResponse,
        RusotoError<CreateHyperParameterTuningJobError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateHyperParameterTuningJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateHyperParameterTuningJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<CreateHyperParameterTuningJobResponse, _>()
    }

    /// <p>Creates a custom SageMaker image. A SageMaker image is a set of image versions. Each image version represents a container image stored in Amazon Container Registry (ECR). For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/studio-byoi.html">Bring your own SageMaker image</a>.</p>
    async fn create_image(
        &self,
        input: CreateImageRequest,
    ) -> Result<CreateImageResponse, RusotoError<CreateImageError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateImage");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateImageError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateImageResponse, _>()
    }

    /// <p>Creates a version of the SageMaker image specified by <code>ImageName</code>. The version represents the Amazon Container Registry (ECR) container image specified by <code>BaseImage</code>.</p>
    async fn create_image_version(
        &self,
        input: CreateImageVersionRequest,
    ) -> Result<CreateImageVersionResponse, RusotoError<CreateImageVersionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateImageVersion");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateImageVersionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateImageVersionResponse, _>()
    }

    /// <p>Creates a job that uses workers to label the data objects in your input dataset. You can use the labeled data to train machine learning models.</p> <p>You can select your workforce from one of three providers:</p> <ul> <li> <p>A private workforce that you create. It can include employees, contractors, and outside experts. Use a private workforce when want the data to stay within your organization or when a specific set of skills is required.</p> </li> <li> <p>One or more vendors that you select from the AWS Marketplace. Vendors provide expertise in specific areas. </p> </li> <li> <p>The Amazon Mechanical Turk workforce. This is the largest workforce, but it should only be used for public data or data that has been stripped of any personally identifiable information.</p> </li> </ul> <p>You can also use <i>automated data labeling</i> to reduce the number of data objects that need to be labeled by a human. Automated data labeling uses <i>active learning</i> to determine if a data object can be labeled by machine or if it needs to be sent to a human worker. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-automated-labeling.html">Using Automated Data Labeling</a>.</p> <p>The data objects to be labeled are contained in an Amazon S3 bucket. You create a <i>manifest file</i> that describes the location of each object. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data.html">Using Input and Output Data</a>.</p> <p>The output can be used as the manifest file for another labeling job or as training data for your machine learning models.</p>
    async fn create_labeling_job(
        &self,
        input: CreateLabelingJobRequest,
    ) -> Result<CreateLabelingJobResponse, RusotoError<CreateLabelingJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateLabelingJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateLabelingJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateLabelingJobResponse, _>()
    }

    /// <p>Creates a model in Amazon SageMaker. In the request, you name the model and describe a primary container. For the primary container, you specify the Docker image that contains inference code, artifacts (from prior training), and a custom environment map that the inference code uses when you deploy the model for predictions.</p> <p>Use this API to create a model if you want to use Amazon SageMaker hosting services or run a batch transform job.</p> <p>To host your model, you create an endpoint configuration with the <code>CreateEndpointConfig</code> API, and then create an endpoint with the <code>CreateEndpoint</code> API. Amazon SageMaker then deploys all of the containers that you defined for the model in the hosting environment. </p> <p>For an example that calls this method when deploying a model to Amazon SageMaker hosting services, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/ex1-deploy-model.html#ex1-deploy-model-boto">Deploy the Model to Amazon SageMaker Hosting Services (AWS SDK for Python (Boto 3)).</a> </p> <p>To run a batch transform using your model, you start a job with the <code>CreateTransformJob</code> API. Amazon SageMaker uses your model and your dataset to get inferences which are then saved to a specified S3 location.</p> <p>In the <code>CreateModel</code> request, you must define a container with the <code>PrimaryContainer</code> parameter.</p> <p>In the request, you also provide an IAM role that Amazon SageMaker can assume to access model artifacts and docker image for deployment on ML compute hosting instances or for batch transform jobs. In addition, you also use the IAM role to manage permissions the inference code needs. For example, if the inference code access any other AWS resources, you grant necessary permissions via this role.</p>
    async fn create_model(
        &self,
        input: CreateModelInput,
    ) -> Result<CreateModelOutput, RusotoError<CreateModelError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateModel");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateModelError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateModelOutput, _>()
    }

    /// <p>Creates the definition for a model bias job.</p>
    async fn create_model_bias_job_definition(
        &self,
        input: CreateModelBiasJobDefinitionRequest,
    ) -> Result<CreateModelBiasJobDefinitionResponse, RusotoError<CreateModelBiasJobDefinitionError>>
    {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateModelBiasJobDefinition");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateModelBiasJobDefinitionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<CreateModelBiasJobDefinitionResponse, _>()
    }

    /// <p>Creates the definition for a model explainability job.</p>
    async fn create_model_explainability_job_definition(
        &self,
        input: CreateModelExplainabilityJobDefinitionRequest,
    ) -> Result<
        CreateModelExplainabilityJobDefinitionResponse,
        RusotoError<CreateModelExplainabilityJobDefinitionError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.CreateModelExplainabilityJobDefinition",
        );
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                CreateModelExplainabilityJobDefinitionError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<CreateModelExplainabilityJobDefinitionResponse, _>()
    }

    /// <p><p>Creates a model package that you can use to create Amazon SageMaker models or list on AWS Marketplace, or a versioned model that is part of a model group. Buyers can subscribe to model packages listed on AWS Marketplace to create models in Amazon SageMaker.</p> <p>To create a model package by specifying a Docker container that contains your inference code and the Amazon S3 location of your model artifacts, provide values for <code>InferenceSpecification</code>. To create a model from an algorithm resource that you created or subscribed to in AWS Marketplace, provide a value for <code>SourceAlgorithmSpecification</code>.</p> <note> <p>There are two types of model packages:</p> <ul> <li> <p>Versioned - a model that is part of a model group in the model registry.</p> </li> <li> <p>Unversioned - a model package that is not part of a model group.</p> </li> </ul> </note></p>
    async fn create_model_package(
        &self,
        input: CreateModelPackageInput,
    ) -> Result<CreateModelPackageOutput, RusotoError<CreateModelPackageError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateModelPackage");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateModelPackageError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateModelPackageOutput, _>()
    }

    /// <p>Creates a model group. A model group contains a group of model versions.</p>
    async fn create_model_package_group(
        &self,
        input: CreateModelPackageGroupInput,
    ) -> Result<CreateModelPackageGroupOutput, RusotoError<CreateModelPackageGroupError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateModelPackageGroup");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateModelPackageGroupError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<CreateModelPackageGroupOutput, _>()
    }

    /// <p>Creates a definition for a job that monitors model quality and drift. For information about model monitor, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor.html">Amazon SageMaker Model Monitor</a>.</p>
    async fn create_model_quality_job_definition(
        &self,
        input: CreateModelQualityJobDefinitionRequest,
    ) -> Result<
        CreateModelQualityJobDefinitionResponse,
        RusotoError<CreateModelQualityJobDefinitionError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateModelQualityJobDefinition");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateModelQualityJobDefinitionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<CreateModelQualityJobDefinitionResponse, _>()
    }

    /// <p>Creates a schedule that regularly starts Amazon SageMaker Processing Jobs to monitor the data captured for an Amazon SageMaker Endoint.</p>
    async fn create_monitoring_schedule(
        &self,
        input: CreateMonitoringScheduleRequest,
    ) -> Result<CreateMonitoringScheduleResponse, RusotoError<CreateMonitoringScheduleError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateMonitoringSchedule");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateMonitoringScheduleError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<CreateMonitoringScheduleResponse, _>()
    }

    /// <p>Creates an Amazon SageMaker notebook instance. A notebook instance is a machine learning (ML) compute instance running on a Jupyter notebook. </p> <p>In a <code>CreateNotebookInstance</code> request, specify the type of ML compute instance that you want to run. Amazon SageMaker launches the instance, installs common libraries that you can use to explore datasets for model training, and attaches an ML storage volume to the notebook instance. </p> <p>Amazon SageMaker also provides a set of example notebooks. Each notebook demonstrates how to use Amazon SageMaker with a specific algorithm or with a machine learning framework. </p> <p>After receiving the request, Amazon SageMaker does the following:</p> <ol> <li> <p>Creates a network interface in the Amazon SageMaker VPC.</p> </li> <li> <p>(Option) If you specified <code>SubnetId</code>, Amazon SageMaker creates a network interface in your own VPC, which is inferred from the subnet ID that you provide in the input. When creating this network interface, Amazon SageMaker attaches the security group that you specified in the request to the network interface that it creates in your VPC.</p> </li> <li> <p>Launches an EC2 instance of the type specified in the request in the Amazon SageMaker VPC. If you specified <code>SubnetId</code> of your VPC, Amazon SageMaker specifies both network interfaces when launching this instance. This enables inbound traffic from your own VPC to the notebook instance, assuming that the security groups allow it.</p> </li> </ol> <p>After creating the notebook instance, Amazon SageMaker returns its Amazon Resource Name (ARN). You can't change the name of a notebook instance after you create it.</p> <p>After Amazon SageMaker creates the notebook instance, you can connect to the Jupyter server and work in Jupyter notebooks. For example, you can write code to explore a dataset that you can use for model training, train a model, host models by creating Amazon SageMaker endpoints, and validate hosted models. </p> <p>For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works.html">How It Works</a>. </p>
    async fn create_notebook_instance(
        &self,
        input: CreateNotebookInstanceInput,
    ) -> Result<CreateNotebookInstanceOutput, RusotoError<CreateNotebookInstanceError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateNotebookInstance");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateNotebookInstanceError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<CreateNotebookInstanceOutput, _>()
    }

    /// <p>Creates a lifecycle configuration that you can associate with a notebook instance. A <i>lifecycle configuration</i> is a collection of shell scripts that run when you create or start a notebook instance.</p> <p>Each lifecycle configuration script has a limit of 16384 characters.</p> <p>The value of the <code>$PATH</code> environment variable that is available to both scripts is <code>/sbin:bin:/usr/sbin:/usr/bin</code>.</p> <p>View CloudWatch Logs for notebook instance lifecycle configurations in log group <code>/aws/sagemaker/NotebookInstances</code> in log stream <code>[notebook-instance-name]/[LifecycleConfigHook]</code>.</p> <p>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.</p> <p>For information about notebook instance lifestyle configurations, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/notebook-lifecycle-config.html">Step 2.1: (Optional) Customize a Notebook Instance</a>.</p>
    async fn create_notebook_instance_lifecycle_config(
        &self,
        input: CreateNotebookInstanceLifecycleConfigInput,
    ) -> Result<
        CreateNotebookInstanceLifecycleConfigOutput,
        RusotoError<CreateNotebookInstanceLifecycleConfigError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.CreateNotebookInstanceLifecycleConfig",
        );
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                CreateNotebookInstanceLifecycleConfigError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<CreateNotebookInstanceLifecycleConfigOutput, _>()
    }

    /// <p>Creates a pipeline using a JSON pipeline definition.</p>
    async fn create_pipeline(
        &self,
        input: CreatePipelineRequest,
    ) -> Result<CreatePipelineResponse, RusotoError<CreatePipelineError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreatePipeline");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreatePipelineError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreatePipelineResponse, _>()
    }

    /// <p><p>Creates a URL for a specified UserProfile in a Domain. When accessed in a web browser, the user will be automatically signed in to Amazon SageMaker Studio, and granted access to all of the Apps and files associated with the Domain&#39;s Amazon Elastic File System (EFS) volume. This operation can only be called when the authentication mode equals IAM. </p> <note> <p>The URL that you get from a call to <code>CreatePresignedDomainUrl</code> is valid only for 5 minutes. If you try to use the URL after the 5-minute limit expires, you are directed to the AWS console sign-in page.</p> </note></p>
    async fn create_presigned_domain_url(
        &self,
        input: CreatePresignedDomainUrlRequest,
    ) -> Result<CreatePresignedDomainUrlResponse, RusotoError<CreatePresignedDomainUrlError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreatePresignedDomainUrl");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreatePresignedDomainUrlError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<CreatePresignedDomainUrlResponse, _>()
    }

    /// <p><p>Returns a URL that you can use to connect to the Jupyter server from a notebook instance. In the Amazon SageMaker console, when you choose <code>Open</code> next to a notebook instance, Amazon SageMaker opens a new tab showing the Jupyter server home page from the notebook instance. The console uses this API to get the URL and show the page.</p> <p> The IAM role or user used to call this API defines the permissions to access the notebook instance. Once the presigned URL is created, no additional permission is required to access this URL. IAM authorization policies for this API are also enforced for every HTTP request and WebSocket frame that attempts to connect to the notebook instance.</p> <p>You can restrict access to this API and to the URL that it returns to a list of IP addresses that you specify. Use the <code>NotIpAddress</code> condition operator and the <code>aws:SourceIP</code> condition context key to specify the list of IP addresses that you want to have access to the notebook instance. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/security_iam_id-based-policy-examples.html#nbi-ip-filter">Limit Access to a Notebook Instance by IP Address</a>.</p> <note> <p>The URL that you get from a call to <a>CreatePresignedNotebookInstanceUrl</a> is valid only for 5 minutes. If you try to use the URL after the 5-minute limit expires, you are directed to the AWS console sign-in page.</p> </note></p>
    async fn create_presigned_notebook_instance_url(
        &self,
        input: CreatePresignedNotebookInstanceUrlInput,
    ) -> Result<
        CreatePresignedNotebookInstanceUrlOutput,
        RusotoError<CreatePresignedNotebookInstanceUrlError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.CreatePresignedNotebookInstanceUrl",
        );
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                CreatePresignedNotebookInstanceUrlError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<CreatePresignedNotebookInstanceUrlOutput, _>()
    }

    /// <p>Creates a processing job.</p>
    async fn create_processing_job(
        &self,
        input: CreateProcessingJobRequest,
    ) -> Result<CreateProcessingJobResponse, RusotoError<CreateProcessingJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateProcessingJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateProcessingJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateProcessingJobResponse, _>()
    }

    /// <p>Creates a machine learning (ML) project that can contain one or more templates that set up an ML pipeline from training to deploying an approved model.</p>
    async fn create_project(
        &self,
        input: CreateProjectInput,
    ) -> Result<CreateProjectOutput, RusotoError<CreateProjectError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateProject");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateProjectError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateProjectOutput, _>()
    }

    /// <p>Starts a model training job. After training completes, Amazon SageMaker saves the resulting model artifacts to an Amazon S3 location that you specify. </p> <p>If you choose to host your model using Amazon SageMaker hosting services, you can use the resulting model artifacts as part of the model. You can also use the artifacts in a machine learning service other than Amazon SageMaker, provided that you know how to use them for inference. </p> <p>In the request body, you provide the following: </p> <ul> <li> <p> <code>AlgorithmSpecification</code> - Identifies the training algorithm to use. </p> </li> <li> <p> <code>HyperParameters</code> - Specify these algorithm-specific parameters to enable the estimation of model parameters during training. Hyperparameters can be tuned to optimize this learning process. For a list of hyperparameters for each training algorithm provided by Amazon SageMaker, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html">Algorithms</a>. </p> </li> <li> <p> <code>InputDataConfig</code> - Describes the training dataset and the Amazon S3, EFS, or FSx location where it is stored.</p> </li> <li> <p> <code>OutputDataConfig</code> - Identifies the Amazon S3 bucket where you want Amazon SageMaker to save the results of model training. </p> <p/> </li> <li> <p> <code>ResourceConfig</code> - Identifies the resources, ML compute instances, and ML storage volumes to deploy for model training. In distributed training, you specify more than one instance. </p> </li> <li> <p> <code>EnableManagedSpotTraining</code> - Optimize the cost of training machine learning models by up to 80% by using Amazon EC2 Spot instances. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html">Managed Spot Training</a>. </p> </li> <li> <p> <code>RoleArn</code> - The Amazon Resource Number (ARN) that Amazon SageMaker assumes to perform tasks on your behalf during model training. You must grant this role the necessary permissions so that Amazon SageMaker can successfully complete model training. </p> </li> <li> <p> <code>StoppingCondition</code> - To help cap training costs, use <code>MaxRuntimeInSeconds</code> to set a time limit for training. Use <code>MaxWaitTimeInSeconds</code> to specify how long you are willing to wait for a managed spot training job to complete. </p> </li> </ul> <p> For more information about Amazon SageMaker, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works.html">How It Works</a>. </p>
    async fn create_training_job(
        &self,
        input: CreateTrainingJobRequest,
    ) -> Result<CreateTrainingJobResponse, RusotoError<CreateTrainingJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateTrainingJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateTrainingJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateTrainingJobResponse, _>()
    }

    /// <p>Starts a transform job. A transform job uses a trained model to get inferences on a dataset and saves these results to an Amazon S3 location that you specify.</p> <p>To perform batch transformations, you create a transform job and use the data that you have readily available.</p> <p>In the request body, you provide the following:</p> <ul> <li> <p> <code>TransformJobName</code> - Identifies the transform job. The name must be unique within an AWS Region in an AWS account.</p> </li> <li> <p> <code>ModelName</code> - Identifies the model to use. <code>ModelName</code> must be the name of an existing Amazon SageMaker model in the same AWS Region and AWS account. For information on creating a model, see <a>CreateModel</a>.</p> </li> <li> <p> <code>TransformInput</code> - Describes the dataset to be transformed and the Amazon S3 location where it is stored.</p> </li> <li> <p> <code>TransformOutput</code> - Identifies the Amazon S3 location where you want Amazon SageMaker to save the results from the transform job.</p> </li> <li> <p> <code>TransformResources</code> - Identifies the ML compute instances for the transform job.</p> </li> </ul> <p>For more information about how batch transformation works, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform.html">Batch Transform</a>.</p>
    async fn create_transform_job(
        &self,
        input: CreateTransformJobRequest,
    ) -> Result<CreateTransformJobResponse, RusotoError<CreateTransformJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateTransformJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateTransformJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateTransformJobResponse, _>()
    }

    /// <p>Creates an Amazon SageMaker <i>trial</i>. A trial is a set of steps called <i>trial components</i> that produce a machine learning model. A trial is part of a single Amazon SageMaker <i>experiment</i>.</p> <p>When you use Amazon SageMaker Studio or the Amazon SageMaker Python SDK, all experiments, trials, and trial components are automatically tracked, logged, and indexed. When you use the AWS SDK for Python (Boto), you must use the logging APIs provided by the SDK.</p> <p>You can add tags to a trial and then use the <a>Search</a> API to search for the tags.</p> <p>To get a list of all your trials, call the <a>ListTrials</a> API. To view a trial's properties, call the <a>DescribeTrial</a> API. To create a trial component, call the <a>CreateTrialComponent</a> API.</p>
    async fn create_trial(
        &self,
        input: CreateTrialRequest,
    ) -> Result<CreateTrialResponse, RusotoError<CreateTrialError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateTrial");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateTrialError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateTrialResponse, _>()
    }

    /// <p><p>Creates a <i>trial component</i>, which is a stage of a machine learning <i>trial</i>. A trial is composed of one or more trial components. A trial component can be used in multiple trials.</p> <p>Trial components include pre-processing jobs, training jobs, and batch transform jobs.</p> <p>When you use Amazon SageMaker Studio or the Amazon SageMaker Python SDK, all experiments, trials, and trial components are automatically tracked, logged, and indexed. When you use the AWS SDK for Python (Boto), you must use the logging APIs provided by the SDK.</p> <p>You can add tags to a trial component and then use the <a>Search</a> API to search for the tags.</p> <note> <p> <code>CreateTrialComponent</code> can only be invoked from within an Amazon SageMaker managed environment. This includes Amazon SageMaker training jobs, processing jobs, transform jobs, and Amazon SageMaker notebooks. A call to <code>CreateTrialComponent</code> from outside one of these environments results in an error.</p> </note></p>
    async fn create_trial_component(
        &self,
        input: CreateTrialComponentRequest,
    ) -> Result<CreateTrialComponentResponse, RusotoError<CreateTrialComponentError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateTrialComponent");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateTrialComponentError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<CreateTrialComponentResponse, _>()
    }

    /// <p>Creates a user profile. A user profile represents a single user within a domain, and is the main way to reference a "person" for the purposes of sharing, reporting, and other user-oriented features. This entity is created when a user onboards to Amazon SageMaker Studio. If an administrator invites a person by email or imports them from SSO, a user profile is automatically created. A user profile is the primary holder of settings for an individual user and has a reference to the user's private Amazon Elastic File System (EFS) home directory. </p>
    async fn create_user_profile(
        &self,
        input: CreateUserProfileRequest,
    ) -> Result<CreateUserProfileResponse, RusotoError<CreateUserProfileError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateUserProfile");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateUserProfileError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateUserProfileResponse, _>()
    }

    /// <p>Use this operation to create a workforce. This operation will return an error if a workforce already exists in the AWS Region that you specify. You can only create one workforce in each AWS Region per AWS account.</p> <p>If you want to create a new workforce in an AWS Region where a workforce already exists, use the API operation to delete the existing workforce and then use <code>CreateWorkforce</code> to create a new workforce.</p> <p>To create a private workforce using Amazon Cognito, you must specify a Cognito user pool in <code>CognitoConfig</code>. You can also create an Amazon Cognito workforce using the Amazon SageMaker console. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-create-private.html"> Create a Private Workforce (Amazon Cognito)</a>.</p> <p>To create a private workforce using your own OIDC Identity Provider (IdP), specify your IdP configuration in <code>OidcConfig</code>. Your OIDC IdP must support <i>groups</i> because groups are used by Ground Truth and Amazon A2I to create work teams. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-create-private-oidc.html"> Create a Private Workforce (OIDC IdP)</a>.</p>
    async fn create_workforce(
        &self,
        input: CreateWorkforceRequest,
    ) -> Result<CreateWorkforceResponse, RusotoError<CreateWorkforceError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateWorkforce");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateWorkforceError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateWorkforceResponse, _>()
    }

    /// <p>Creates a new work team for labeling your data. A work team is defined by one or more Amazon Cognito user pools. You must first create the user pools before you can create a work team.</p> <p>You cannot create more than 25 work teams in an account and region.</p>
    async fn create_workteam(
        &self,
        input: CreateWorkteamRequest,
    ) -> Result<CreateWorkteamResponse, RusotoError<CreateWorkteamError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.CreateWorkteam");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, CreateWorkteamError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<CreateWorkteamResponse, _>()
    }

    /// <p>Deletes an action.</p>
    async fn delete_action(
        &self,
        input: DeleteActionRequest,
    ) -> Result<DeleteActionResponse, RusotoError<DeleteActionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteAction");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteActionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DeleteActionResponse, _>()
    }

    /// <p>Removes the specified algorithm from your account.</p>
    async fn delete_algorithm(
        &self,
        input: DeleteAlgorithmInput,
    ) -> Result<(), RusotoError<DeleteAlgorithmError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteAlgorithm");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteAlgorithmError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Used to stop and delete an app.</p>
    async fn delete_app(&self, input: DeleteAppRequest) -> Result<(), RusotoError<DeleteAppError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteApp");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteAppError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes an AppImageConfig.</p>
    async fn delete_app_image_config(
        &self,
        input: DeleteAppImageConfigRequest,
    ) -> Result<(), RusotoError<DeleteAppImageConfigError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteAppImageConfig");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteAppImageConfigError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes an artifact. Either <code>ArtifactArn</code> or <code>Source</code> must be specified.</p>
    async fn delete_artifact(
        &self,
        input: DeleteArtifactRequest,
    ) -> Result<DeleteArtifactResponse, RusotoError<DeleteArtifactError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteArtifact");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteArtifactError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DeleteArtifactResponse, _>()
    }

    /// <p>Deletes an association.</p>
    async fn delete_association(
        &self,
        input: DeleteAssociationRequest,
    ) -> Result<DeleteAssociationResponse, RusotoError<DeleteAssociationError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteAssociation");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteAssociationError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DeleteAssociationResponse, _>()
    }

    /// <p>Deletes the specified Git repository from your account.</p>
    async fn delete_code_repository(
        &self,
        input: DeleteCodeRepositoryInput,
    ) -> Result<(), RusotoError<DeleteCodeRepositoryError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteCodeRepository");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteCodeRepositoryError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes an context.</p>
    async fn delete_context(
        &self,
        input: DeleteContextRequest,
    ) -> Result<DeleteContextResponse, RusotoError<DeleteContextError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteContext");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteContextError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DeleteContextResponse, _>()
    }

    /// <p>Deletes a data quality monitoring job definition.</p>
    async fn delete_data_quality_job_definition(
        &self,
        input: DeleteDataQualityJobDefinitionRequest,
    ) -> Result<(), RusotoError<DeleteDataQualityJobDefinitionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteDataQualityJobDefinition");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteDataQualityJobDefinitionError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes a fleet.</p>
    async fn delete_device_fleet(
        &self,
        input: DeleteDeviceFleetRequest,
    ) -> Result<(), RusotoError<DeleteDeviceFleetError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteDeviceFleet");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteDeviceFleetError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Used to delete a domain. If you onboarded with IAM mode, you will need to delete your domain to onboard again using SSO. Use with caution. All of the members of the domain will lose access to their EFS volume, including data, notebooks, and other artifacts. </p>
    async fn delete_domain(
        &self,
        input: DeleteDomainRequest,
    ) -> Result<(), RusotoError<DeleteDomainError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteDomain");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteDomainError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes an endpoint. Amazon SageMaker frees up all of the resources that were deployed when the endpoint was created. </p> <p>Amazon SageMaker retires any custom KMS key grants associated with the endpoint, meaning you don't need to use the <a href="http://docs.aws.amazon.com/kms/latest/APIReference/API_RevokeGrant.html">RevokeGrant</a> API call.</p>
    async fn delete_endpoint(
        &self,
        input: DeleteEndpointInput,
    ) -> Result<(), RusotoError<DeleteEndpointError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteEndpoint");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteEndpointError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes an endpoint configuration. The <code>DeleteEndpointConfig</code> API deletes only the specified configuration. It does not delete endpoints created using the configuration. </p> <p>You must not delete an <code>EndpointConfig</code> in use by an endpoint that is live or while the <code>UpdateEndpoint</code> or <code>CreateEndpoint</code> operations are being performed on the endpoint. If you delete the <code>EndpointConfig</code> of an endpoint that is active or being created or updated you may lose visibility into the instance type the endpoint is using. The endpoint must be deleted in order to stop incurring charges.</p>
    async fn delete_endpoint_config(
        &self,
        input: DeleteEndpointConfigInput,
    ) -> Result<(), RusotoError<DeleteEndpointConfigError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteEndpointConfig");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteEndpointConfigError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes an Amazon SageMaker experiment. All trials associated with the experiment must be deleted first. Use the <a>ListTrials</a> API to get a list of the trials associated with the experiment.</p>
    async fn delete_experiment(
        &self,
        input: DeleteExperimentRequest,
    ) -> Result<DeleteExperimentResponse, RusotoError<DeleteExperimentError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteExperiment");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteExperimentError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DeleteExperimentResponse, _>()
    }

    /// <p>Delete the <code>FeatureGroup</code> and any data that was written to the <code>OnlineStore</code> of the <code>FeatureGroup</code>. Data cannot be accessed from the <code>OnlineStore</code> immediately after <code>DeleteFeatureGroup</code> is called. </p> <p>Data written into the <code>OfflineStore</code> will not be deleted. The AWS Glue database and tables that are automatically created for your <code>OfflineStore</code> are not deleted. </p>
    async fn delete_feature_group(
        &self,
        input: DeleteFeatureGroupRequest,
    ) -> Result<(), RusotoError<DeleteFeatureGroupError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteFeatureGroup");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteFeatureGroupError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes the specified flow definition.</p>
    async fn delete_flow_definition(
        &self,
        input: DeleteFlowDefinitionRequest,
    ) -> Result<DeleteFlowDefinitionResponse, RusotoError<DeleteFlowDefinitionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteFlowDefinition");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteFlowDefinitionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DeleteFlowDefinitionResponse, _>()
    }

    /// <p>Use this operation to delete a human task user interface (worker task template).</p> <p> To see a list of human task user interfaces (work task templates) in your account, use . When you delete a worker task template, it no longer appears when you call <code>ListHumanTaskUis</code>.</p>
    async fn delete_human_task_ui(
        &self,
        input: DeleteHumanTaskUiRequest,
    ) -> Result<DeleteHumanTaskUiResponse, RusotoError<DeleteHumanTaskUiError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteHumanTaskUi");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteHumanTaskUiError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DeleteHumanTaskUiResponse, _>()
    }

    /// <p>Deletes a SageMaker image and all versions of the image. The container images aren't deleted.</p>
    async fn delete_image(
        &self,
        input: DeleteImageRequest,
    ) -> Result<DeleteImageResponse, RusotoError<DeleteImageError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteImage");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteImageError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DeleteImageResponse, _>()
    }

    /// <p>Deletes a version of a SageMaker image. The container image the version represents isn't deleted.</p>
    async fn delete_image_version(
        &self,
        input: DeleteImageVersionRequest,
    ) -> Result<DeleteImageVersionResponse, RusotoError<DeleteImageVersionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteImageVersion");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteImageVersionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DeleteImageVersionResponse, _>()
    }

    /// <p>Deletes a model. The <code>DeleteModel</code> API deletes only the model entry that was created in Amazon SageMaker when you called the <a>CreateModel</a> API. It does not delete model artifacts, inference code, or the IAM role that you specified when creating the model. </p>
    async fn delete_model(
        &self,
        input: DeleteModelInput,
    ) -> Result<(), RusotoError<DeleteModelError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteModel");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteModelError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes an Amazon SageMaker model bias job definition.</p>
    async fn delete_model_bias_job_definition(
        &self,
        input: DeleteModelBiasJobDefinitionRequest,
    ) -> Result<(), RusotoError<DeleteModelBiasJobDefinitionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteModelBiasJobDefinition");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteModelBiasJobDefinitionError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes an Amazon SageMaker model explainability job definition.</p>
    async fn delete_model_explainability_job_definition(
        &self,
        input: DeleteModelExplainabilityJobDefinitionRequest,
    ) -> Result<(), RusotoError<DeleteModelExplainabilityJobDefinitionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.DeleteModelExplainabilityJobDefinition",
        );
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                DeleteModelExplainabilityJobDefinitionError::from_response,
            )
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes a model package.</p> <p>A model package is used to create Amazon SageMaker models or list on AWS Marketplace. Buyers can subscribe to model packages listed on AWS Marketplace to create models in Amazon SageMaker.</p>
    async fn delete_model_package(
        &self,
        input: DeleteModelPackageInput,
    ) -> Result<(), RusotoError<DeleteModelPackageError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteModelPackage");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteModelPackageError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes the specified model group.</p>
    async fn delete_model_package_group(
        &self,
        input: DeleteModelPackageGroupInput,
    ) -> Result<(), RusotoError<DeleteModelPackageGroupError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteModelPackageGroup");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteModelPackageGroupError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes a model group resource policy.</p>
    async fn delete_model_package_group_policy(
        &self,
        input: DeleteModelPackageGroupPolicyInput,
    ) -> Result<(), RusotoError<DeleteModelPackageGroupPolicyError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteModelPackageGroupPolicy");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteModelPackageGroupPolicyError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes the secified model quality monitoring job definition.</p>
    async fn delete_model_quality_job_definition(
        &self,
        input: DeleteModelQualityJobDefinitionRequest,
    ) -> Result<(), RusotoError<DeleteModelQualityJobDefinitionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteModelQualityJobDefinition");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteModelQualityJobDefinitionError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes a monitoring schedule. Also stops the schedule had not already been stopped. This does not delete the job execution history of the monitoring schedule. </p>
    async fn delete_monitoring_schedule(
        &self,
        input: DeleteMonitoringScheduleRequest,
    ) -> Result<(), RusotoError<DeleteMonitoringScheduleError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteMonitoringSchedule");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteMonitoringScheduleError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p><p> Deletes an Amazon SageMaker notebook instance. Before you can delete a notebook instance, you must call the <code>StopNotebookInstance</code> API. </p> <important> <p>When you delete a notebook instance, you lose all of your data. Amazon SageMaker removes the ML compute instance, and deletes the ML storage volume and the network interface associated with the notebook instance. </p> </important></p>
    async fn delete_notebook_instance(
        &self,
        input: DeleteNotebookInstanceInput,
    ) -> Result<(), RusotoError<DeleteNotebookInstanceError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteNotebookInstance");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteNotebookInstanceError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes a notebook instance lifecycle configuration.</p>
    async fn delete_notebook_instance_lifecycle_config(
        &self,
        input: DeleteNotebookInstanceLifecycleConfigInput,
    ) -> Result<(), RusotoError<DeleteNotebookInstanceLifecycleConfigError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.DeleteNotebookInstanceLifecycleConfig",
        );
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                DeleteNotebookInstanceLifecycleConfigError::from_response,
            )
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Deletes a pipeline if there are no in-progress executions.</p>
    async fn delete_pipeline(
        &self,
        input: DeletePipelineRequest,
    ) -> Result<DeletePipelineResponse, RusotoError<DeletePipelineError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeletePipeline");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeletePipelineError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DeletePipelineResponse, _>()
    }

    /// <p>Delete the specified project.</p>
    async fn delete_project(
        &self,
        input: DeleteProjectInput,
    ) -> Result<(), RusotoError<DeleteProjectError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteProject");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteProjectError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p><p>Deletes the specified tags from an Amazon SageMaker resource.</p> <p>To list a resource&#39;s tags, use the <code>ListTags</code> API. </p> <note> <p>When you call this API to delete tags from a hyperparameter tuning job, the deleted tags are not removed from training jobs that the hyperparameter tuning job launched before you called this API.</p> </note></p>
    async fn delete_tags(
        &self,
        input: DeleteTagsInput,
    ) -> Result<DeleteTagsOutput, RusotoError<DeleteTagsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteTags");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteTagsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DeleteTagsOutput, _>()
    }

    /// <p>Deletes the specified trial. All trial components that make up the trial must be deleted first. Use the <a>DescribeTrialComponent</a> API to get the list of trial components.</p>
    async fn delete_trial(
        &self,
        input: DeleteTrialRequest,
    ) -> Result<DeleteTrialResponse, RusotoError<DeleteTrialError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteTrial");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteTrialError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DeleteTrialResponse, _>()
    }

    /// <p>Deletes the specified trial component. A trial component must be disassociated from all trials before the trial component can be deleted. To disassociate a trial component from a trial, call the <a>DisassociateTrialComponent</a> API.</p>
    async fn delete_trial_component(
        &self,
        input: DeleteTrialComponentRequest,
    ) -> Result<DeleteTrialComponentResponse, RusotoError<DeleteTrialComponentError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteTrialComponent");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteTrialComponentError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DeleteTrialComponentResponse, _>()
    }

    /// <p>Deletes a user profile. When a user profile is deleted, the user loses access to their EFS volume, including data, notebooks, and other artifacts.</p>
    async fn delete_user_profile(
        &self,
        input: DeleteUserProfileRequest,
    ) -> Result<(), RusotoError<DeleteUserProfileError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteUserProfile");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteUserProfileError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p><p>Use this operation to delete a workforce.</p> <p>If you want to create a new workforce in an AWS Region where a workforce already exists, use this operation to delete the existing workforce and then use to create a new workforce.</p> <important> <p>If a private workforce contains one or more work teams, you must use the operation to delete all work teams before you delete the workforce. If you try to delete a workforce that contains one or more work teams, you will recieve a <code>ResourceInUse</code> error.</p> </important></p>
    async fn delete_workforce(
        &self,
        input: DeleteWorkforceRequest,
    ) -> Result<DeleteWorkforceResponse, RusotoError<DeleteWorkforceError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteWorkforce");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteWorkforceError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DeleteWorkforceResponse, _>()
    }

    /// <p>Deletes an existing work team. This operation can't be undone.</p>
    async fn delete_workteam(
        &self,
        input: DeleteWorkteamRequest,
    ) -> Result<DeleteWorkteamResponse, RusotoError<DeleteWorkteamError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeleteWorkteam");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeleteWorkteamError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DeleteWorkteamResponse, _>()
    }

    /// <p>Deregisters the specified devices. After you deregister a device, you will need to re-register the devices.</p>
    async fn deregister_devices(
        &self,
        input: DeregisterDevicesRequest,
    ) -> Result<(), RusotoError<DeregisterDevicesError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DeregisterDevices");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DeregisterDevicesError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Describes an action.</p>
    async fn describe_action(
        &self,
        input: DescribeActionRequest,
    ) -> Result<DescribeActionResponse, RusotoError<DescribeActionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeAction");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeActionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeActionResponse, _>()
    }

    /// <p>Returns a description of the specified algorithm that is in your account.</p>
    async fn describe_algorithm(
        &self,
        input: DescribeAlgorithmInput,
    ) -> Result<DescribeAlgorithmOutput, RusotoError<DescribeAlgorithmError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeAlgorithm");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeAlgorithmError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeAlgorithmOutput, _>()
    }

    /// <p>Describes the app.</p>
    async fn describe_app(
        &self,
        input: DescribeAppRequest,
    ) -> Result<DescribeAppResponse, RusotoError<DescribeAppError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeApp");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeAppError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeAppResponse, _>()
    }

    /// <p>Describes an AppImageConfig.</p>
    async fn describe_app_image_config(
        &self,
        input: DescribeAppImageConfigRequest,
    ) -> Result<DescribeAppImageConfigResponse, RusotoError<DescribeAppImageConfigError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeAppImageConfig");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeAppImageConfigError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeAppImageConfigResponse, _>()
    }

    /// <p>Describes an artifact.</p>
    async fn describe_artifact(
        &self,
        input: DescribeArtifactRequest,
    ) -> Result<DescribeArtifactResponse, RusotoError<DescribeArtifactError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeArtifact");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeArtifactError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeArtifactResponse, _>()
    }

    /// <p>Returns information about an Amazon SageMaker job.</p>
    async fn describe_auto_ml_job(
        &self,
        input: DescribeAutoMLJobRequest,
    ) -> Result<DescribeAutoMLJobResponse, RusotoError<DescribeAutoMLJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeAutoMLJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeAutoMLJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeAutoMLJobResponse, _>()
    }

    /// <p>Gets details about the specified Git repository.</p>
    async fn describe_code_repository(
        &self,
        input: DescribeCodeRepositoryInput,
    ) -> Result<DescribeCodeRepositoryOutput, RusotoError<DescribeCodeRepositoryError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeCodeRepository");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeCodeRepositoryError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeCodeRepositoryOutput, _>()
    }

    /// <p>Returns information about a model compilation job.</p> <p>To create a model compilation job, use <a>CreateCompilationJob</a>. To get information about multiple model compilation jobs, use <a>ListCompilationJobs</a>.</p>
    async fn describe_compilation_job(
        &self,
        input: DescribeCompilationJobRequest,
    ) -> Result<DescribeCompilationJobResponse, RusotoError<DescribeCompilationJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeCompilationJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeCompilationJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeCompilationJobResponse, _>()
    }

    /// <p>Describes a context.</p>
    async fn describe_context(
        &self,
        input: DescribeContextRequest,
    ) -> Result<DescribeContextResponse, RusotoError<DescribeContextError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeContext");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeContextError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeContextResponse, _>()
    }

    /// <p>Gets the details of a data quality monitoring job definition.</p>
    async fn describe_data_quality_job_definition(
        &self,
        input: DescribeDataQualityJobDefinitionRequest,
    ) -> Result<
        DescribeDataQualityJobDefinitionResponse,
        RusotoError<DescribeDataQualityJobDefinitionError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeDataQualityJobDefinition");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                DescribeDataQualityJobDefinitionError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeDataQualityJobDefinitionResponse, _>()
    }

    /// <p>Describes the device.</p>
    async fn describe_device(
        &self,
        input: DescribeDeviceRequest,
    ) -> Result<DescribeDeviceResponse, RusotoError<DescribeDeviceError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeDevice");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeDeviceError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeDeviceResponse, _>()
    }

    /// <p>A description of the fleet the device belongs to.</p>
    async fn describe_device_fleet(
        &self,
        input: DescribeDeviceFleetRequest,
    ) -> Result<DescribeDeviceFleetResponse, RusotoError<DescribeDeviceFleetError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeDeviceFleet");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeDeviceFleetError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeDeviceFleetResponse, _>()
    }

    /// <p>The description of the domain.</p>
    async fn describe_domain(
        &self,
        input: DescribeDomainRequest,
    ) -> Result<DescribeDomainResponse, RusotoError<DescribeDomainError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeDomain");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeDomainError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeDomainResponse, _>()
    }

    /// <p>A description of edge packaging jobs.</p>
    async fn describe_edge_packaging_job(
        &self,
        input: DescribeEdgePackagingJobRequest,
    ) -> Result<DescribeEdgePackagingJobResponse, RusotoError<DescribeEdgePackagingJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeEdgePackagingJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeEdgePackagingJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeEdgePackagingJobResponse, _>()
    }

    /// <p>Returns the description of an endpoint.</p>
    async fn describe_endpoint(
        &self,
        input: DescribeEndpointInput,
    ) -> Result<DescribeEndpointOutput, RusotoError<DescribeEndpointError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeEndpoint");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeEndpointError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeEndpointOutput, _>()
    }

    /// <p>Returns the description of an endpoint configuration created using the <code>CreateEndpointConfig</code> API.</p>
    async fn describe_endpoint_config(
        &self,
        input: DescribeEndpointConfigInput,
    ) -> Result<DescribeEndpointConfigOutput, RusotoError<DescribeEndpointConfigError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeEndpointConfig");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeEndpointConfigError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeEndpointConfigOutput, _>()
    }

    /// <p>Provides a list of an experiment's properties.</p>
    async fn describe_experiment(
        &self,
        input: DescribeExperimentRequest,
    ) -> Result<DescribeExperimentResponse, RusotoError<DescribeExperimentError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeExperiment");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeExperimentError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeExperimentResponse, _>()
    }

    /// <p>Use this operation to describe a <code>FeatureGroup</code>. The response includes information on the creation time, <code>FeatureGroup</code> name, the unique identifier for each <code>FeatureGroup</code>, and more.</p>
    async fn describe_feature_group(
        &self,
        input: DescribeFeatureGroupRequest,
    ) -> Result<DescribeFeatureGroupResponse, RusotoError<DescribeFeatureGroupError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeFeatureGroup");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeFeatureGroupError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeFeatureGroupResponse, _>()
    }

    /// <p>Returns information about the specified flow definition.</p>
    async fn describe_flow_definition(
        &self,
        input: DescribeFlowDefinitionRequest,
    ) -> Result<DescribeFlowDefinitionResponse, RusotoError<DescribeFlowDefinitionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeFlowDefinition");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeFlowDefinitionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeFlowDefinitionResponse, _>()
    }

    /// <p>Returns information about the requested human task user interface (worker task template).</p>
    async fn describe_human_task_ui(
        &self,
        input: DescribeHumanTaskUiRequest,
    ) -> Result<DescribeHumanTaskUiResponse, RusotoError<DescribeHumanTaskUiError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeHumanTaskUi");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeHumanTaskUiError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeHumanTaskUiResponse, _>()
    }

    /// <p>Gets a description of a hyperparameter tuning job.</p>
    async fn describe_hyper_parameter_tuning_job(
        &self,
        input: DescribeHyperParameterTuningJobRequest,
    ) -> Result<
        DescribeHyperParameterTuningJobResponse,
        RusotoError<DescribeHyperParameterTuningJobError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeHyperParameterTuningJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeHyperParameterTuningJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeHyperParameterTuningJobResponse, _>()
    }

    /// <p>Describes a SageMaker image.</p>
    async fn describe_image(
        &self,
        input: DescribeImageRequest,
    ) -> Result<DescribeImageResponse, RusotoError<DescribeImageError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeImage");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeImageError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeImageResponse, _>()
    }

    /// <p>Describes a version of a SageMaker image.</p>
    async fn describe_image_version(
        &self,
        input: DescribeImageVersionRequest,
    ) -> Result<DescribeImageVersionResponse, RusotoError<DescribeImageVersionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeImageVersion");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeImageVersionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeImageVersionResponse, _>()
    }

    /// <p>Gets information about a labeling job.</p>
    async fn describe_labeling_job(
        &self,
        input: DescribeLabelingJobRequest,
    ) -> Result<DescribeLabelingJobResponse, RusotoError<DescribeLabelingJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeLabelingJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeLabelingJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeLabelingJobResponse, _>()
    }

    /// <p>Describes a model that you created using the <code>CreateModel</code> API.</p>
    async fn describe_model(
        &self,
        input: DescribeModelInput,
    ) -> Result<DescribeModelOutput, RusotoError<DescribeModelError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeModel");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeModelError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeModelOutput, _>()
    }

    /// <p>Returns a description of a model bias job definition.</p>
    async fn describe_model_bias_job_definition(
        &self,
        input: DescribeModelBiasJobDefinitionRequest,
    ) -> Result<
        DescribeModelBiasJobDefinitionResponse,
        RusotoError<DescribeModelBiasJobDefinitionError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeModelBiasJobDefinition");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeModelBiasJobDefinitionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeModelBiasJobDefinitionResponse, _>()
    }

    /// <p>Returns a description of a model explainability job definition.</p>
    async fn describe_model_explainability_job_definition(
        &self,
        input: DescribeModelExplainabilityJobDefinitionRequest,
    ) -> Result<
        DescribeModelExplainabilityJobDefinitionResponse,
        RusotoError<DescribeModelExplainabilityJobDefinitionError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.DescribeModelExplainabilityJobDefinition",
        );
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                DescribeModelExplainabilityJobDefinitionError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeModelExplainabilityJobDefinitionResponse, _>()
    }

    /// <p>Returns a description of the specified model package, which is used to create Amazon SageMaker models or list them on AWS Marketplace.</p> <p>To create models in Amazon SageMaker, buyers can subscribe to model packages listed on AWS Marketplace.</p>
    async fn describe_model_package(
        &self,
        input: DescribeModelPackageInput,
    ) -> Result<DescribeModelPackageOutput, RusotoError<DescribeModelPackageError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeModelPackage");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeModelPackageError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeModelPackageOutput, _>()
    }

    /// <p>Gets a description for the specified model group.</p>
    async fn describe_model_package_group(
        &self,
        input: DescribeModelPackageGroupInput,
    ) -> Result<DescribeModelPackageGroupOutput, RusotoError<DescribeModelPackageGroupError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeModelPackageGroup");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeModelPackageGroupError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeModelPackageGroupOutput, _>()
    }

    /// <p>Returns a description of a model quality job definition.</p>
    async fn describe_model_quality_job_definition(
        &self,
        input: DescribeModelQualityJobDefinitionRequest,
    ) -> Result<
        DescribeModelQualityJobDefinitionResponse,
        RusotoError<DescribeModelQualityJobDefinitionError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.DescribeModelQualityJobDefinition",
        );
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                DescribeModelQualityJobDefinitionError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeModelQualityJobDefinitionResponse, _>()
    }

    /// <p>Describes the schedule for a monitoring job.</p>
    async fn describe_monitoring_schedule(
        &self,
        input: DescribeMonitoringScheduleRequest,
    ) -> Result<DescribeMonitoringScheduleResponse, RusotoError<DescribeMonitoringScheduleError>>
    {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeMonitoringSchedule");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeMonitoringScheduleError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeMonitoringScheduleResponse, _>()
    }

    /// <p>Returns information about a notebook instance.</p>
    async fn describe_notebook_instance(
        &self,
        input: DescribeNotebookInstanceInput,
    ) -> Result<DescribeNotebookInstanceOutput, RusotoError<DescribeNotebookInstanceError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeNotebookInstance");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeNotebookInstanceError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeNotebookInstanceOutput, _>()
    }

    /// <p>Returns a description of a notebook instance lifecycle configuration.</p> <p>For information about notebook instance lifestyle configurations, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/notebook-lifecycle-config.html">Step 2.1: (Optional) Customize a Notebook Instance</a>.</p>
    async fn describe_notebook_instance_lifecycle_config(
        &self,
        input: DescribeNotebookInstanceLifecycleConfigInput,
    ) -> Result<
        DescribeNotebookInstanceLifecycleConfigOutput,
        RusotoError<DescribeNotebookInstanceLifecycleConfigError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.DescribeNotebookInstanceLifecycleConfig",
        );
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                DescribeNotebookInstanceLifecycleConfigError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeNotebookInstanceLifecycleConfigOutput, _>()
    }

    /// <p>Describes the details of a pipeline.</p>
    async fn describe_pipeline(
        &self,
        input: DescribePipelineRequest,
    ) -> Result<DescribePipelineResponse, RusotoError<DescribePipelineError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribePipeline");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribePipelineError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribePipelineResponse, _>()
    }

    /// <p>Describes the details of an execution's pipeline definition.</p>
    async fn describe_pipeline_definition_for_execution(
        &self,
        input: DescribePipelineDefinitionForExecutionRequest,
    ) -> Result<
        DescribePipelineDefinitionForExecutionResponse,
        RusotoError<DescribePipelineDefinitionForExecutionError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.DescribePipelineDefinitionForExecution",
        );
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                DescribePipelineDefinitionForExecutionError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribePipelineDefinitionForExecutionResponse, _>()
    }

    /// <p>Describes the details of a pipeline execution.</p>
    async fn describe_pipeline_execution(
        &self,
        input: DescribePipelineExecutionRequest,
    ) -> Result<DescribePipelineExecutionResponse, RusotoError<DescribePipelineExecutionError>>
    {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribePipelineExecution");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribePipelineExecutionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribePipelineExecutionResponse, _>()
    }

    /// <p>Returns a description of a processing job.</p>
    async fn describe_processing_job(
        &self,
        input: DescribeProcessingJobRequest,
    ) -> Result<DescribeProcessingJobResponse, RusotoError<DescribeProcessingJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeProcessingJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeProcessingJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeProcessingJobResponse, _>()
    }

    /// <p>Describes the details of a project.</p>
    async fn describe_project(
        &self,
        input: DescribeProjectInput,
    ) -> Result<DescribeProjectOutput, RusotoError<DescribeProjectError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeProject");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeProjectError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeProjectOutput, _>()
    }

    /// <p>Gets information about a work team provided by a vendor. It returns details about the subscription with a vendor in the AWS Marketplace.</p>
    async fn describe_subscribed_workteam(
        &self,
        input: DescribeSubscribedWorkteamRequest,
    ) -> Result<DescribeSubscribedWorkteamResponse, RusotoError<DescribeSubscribedWorkteamError>>
    {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeSubscribedWorkteam");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeSubscribedWorkteamError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeSubscribedWorkteamResponse, _>()
    }

    /// <p>Returns information about a training job.</p>
    async fn describe_training_job(
        &self,
        input: DescribeTrainingJobRequest,
    ) -> Result<DescribeTrainingJobResponse, RusotoError<DescribeTrainingJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeTrainingJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeTrainingJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeTrainingJobResponse, _>()
    }

    /// <p>Returns information about a transform job.</p>
    async fn describe_transform_job(
        &self,
        input: DescribeTransformJobRequest,
    ) -> Result<DescribeTransformJobResponse, RusotoError<DescribeTransformJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeTransformJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeTransformJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeTransformJobResponse, _>()
    }

    /// <p>Provides a list of a trial's properties.</p>
    async fn describe_trial(
        &self,
        input: DescribeTrialRequest,
    ) -> Result<DescribeTrialResponse, RusotoError<DescribeTrialError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeTrial");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeTrialError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeTrialResponse, _>()
    }

    /// <p>Provides a list of a trials component's properties.</p>
    async fn describe_trial_component(
        &self,
        input: DescribeTrialComponentRequest,
    ) -> Result<DescribeTrialComponentResponse, RusotoError<DescribeTrialComponentError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeTrialComponent");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeTrialComponentError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DescribeTrialComponentResponse, _>()
    }

    /// <p>Describes a user profile. For more information, see <code>CreateUserProfile</code>.</p>
    async fn describe_user_profile(
        &self,
        input: DescribeUserProfileRequest,
    ) -> Result<DescribeUserProfileResponse, RusotoError<DescribeUserProfileError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeUserProfile");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeUserProfileError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeUserProfileResponse, _>()
    }

    /// <p><p>Lists private workforce information, including workforce name, Amazon Resource Name (ARN), and, if applicable, allowed IP address ranges (<a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html">CIDRs</a>). Allowable IP address ranges are the IP addresses that workers can use to access tasks. </p> <important> <p>This operation applies only to private workforces.</p> </important></p>
    async fn describe_workforce(
        &self,
        input: DescribeWorkforceRequest,
    ) -> Result<DescribeWorkforceResponse, RusotoError<DescribeWorkforceError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeWorkforce");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeWorkforceError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeWorkforceResponse, _>()
    }

    /// <p>Gets information about a specific work team. You can see information such as the create date, the last updated date, membership information, and the work team's Amazon Resource Name (ARN).</p>
    async fn describe_workteam(
        &self,
        input: DescribeWorkteamRequest,
    ) -> Result<DescribeWorkteamResponse, RusotoError<DescribeWorkteamError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DescribeWorkteam");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DescribeWorkteamError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<DescribeWorkteamResponse, _>()
    }

    /// <p>Disables using Service Catalog in SageMaker. Service Catalog is used to create SageMaker projects.</p>
    async fn disable_sagemaker_servicecatalog_portfolio(
        &self,
    ) -> Result<
        DisableSagemakerServicecatalogPortfolioOutput,
        RusotoError<DisableSagemakerServicecatalogPortfolioError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.DisableSagemakerServicecatalogPortfolio",
        );
        request.set_payload(Some(bytes::Bytes::from_static(b"{}")));

        let response = self
            .sign_and_dispatch(
                request,
                DisableSagemakerServicecatalogPortfolioError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DisableSagemakerServicecatalogPortfolioOutput, _>()
    }

    /// <p>Disassociates a trial component from a trial. This doesn't effect other trials the component is associated with. Before you can delete a component, you must disassociate the component from all trials it is associated with. To associate a trial component with a trial, call the <a>AssociateTrialComponent</a> API.</p> <p>To get a list of the trials a component is associated with, use the <a>Search</a> API. Specify <code>ExperimentTrialComponent</code> for the <code>Resource</code> parameter. The list appears in the response under <code>Results.TrialComponent.Parents</code>.</p>
    async fn disassociate_trial_component(
        &self,
        input: DisassociateTrialComponentRequest,
    ) -> Result<DisassociateTrialComponentResponse, RusotoError<DisassociateTrialComponentError>>
    {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.DisassociateTrialComponent");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, DisassociateTrialComponentError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<DisassociateTrialComponentResponse, _>()
    }

    /// <p>Enables using Service Catalog in SageMaker. Service Catalog is used to create SageMaker projects.</p>
    async fn enable_sagemaker_servicecatalog_portfolio(
        &self,
    ) -> Result<
        EnableSagemakerServicecatalogPortfolioOutput,
        RusotoError<EnableSagemakerServicecatalogPortfolioError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.EnableSagemakerServicecatalogPortfolio",
        );
        request.set_payload(Some(bytes::Bytes::from_static(b"{}")));

        let response = self
            .sign_and_dispatch(
                request,
                EnableSagemakerServicecatalogPortfolioError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<EnableSagemakerServicecatalogPortfolioOutput, _>()
    }

    /// <p>Describes a fleet.</p>
    async fn get_device_fleet_report(
        &self,
        input: GetDeviceFleetReportRequest,
    ) -> Result<GetDeviceFleetReportResponse, RusotoError<GetDeviceFleetReportError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.GetDeviceFleetReport");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, GetDeviceFleetReportError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<GetDeviceFleetReportResponse, _>()
    }

    /// <p>Gets a resource policy that manages access for a model group. For information about resource policies, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html">Identity-based policies and resource-based policies</a> in the <i>AWS Identity and Access Management User Guide.</i>.</p>
    async fn get_model_package_group_policy(
        &self,
        input: GetModelPackageGroupPolicyInput,
    ) -> Result<GetModelPackageGroupPolicyOutput, RusotoError<GetModelPackageGroupPolicyError>>
    {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.GetModelPackageGroupPolicy");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, GetModelPackageGroupPolicyError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<GetModelPackageGroupPolicyOutput, _>()
    }

    /// <p>Gets the status of Service Catalog in SageMaker. Service Catalog is used to create SageMaker projects.</p>
    async fn get_sagemaker_servicecatalog_portfolio_status(
        &self,
    ) -> Result<
        GetSagemakerServicecatalogPortfolioStatusOutput,
        RusotoError<GetSagemakerServicecatalogPortfolioStatusError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.GetSagemakerServicecatalogPortfolioStatus",
        );
        request.set_payload(Some(bytes::Bytes::from_static(b"{}")));

        let response = self
            .sign_and_dispatch(
                request,
                GetSagemakerServicecatalogPortfolioStatusError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<GetSagemakerServicecatalogPortfolioStatusOutput, _>()
    }

    /// <p>An auto-complete API for the search functionality in the Amazon SageMaker console. It returns suggestions of possible matches for the property name to use in <code>Search</code> queries. Provides suggestions for <code>HyperParameters</code>, <code>Tags</code>, and <code>Metrics</code>.</p>
    async fn get_search_suggestions(
        &self,
        input: GetSearchSuggestionsRequest,
    ) -> Result<GetSearchSuggestionsResponse, RusotoError<GetSearchSuggestionsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.GetSearchSuggestions");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, GetSearchSuggestionsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<GetSearchSuggestionsResponse, _>()
    }

    /// <p>Lists the actions in your account and their properties.</p>
    async fn list_actions(
        &self,
        input: ListActionsRequest,
    ) -> Result<ListActionsResponse, RusotoError<ListActionsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListActions");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListActionsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListActionsResponse, _>()
    }

    /// <p>Lists the machine learning algorithms that have been created.</p>
    async fn list_algorithms(
        &self,
        input: ListAlgorithmsInput,
    ) -> Result<ListAlgorithmsOutput, RusotoError<ListAlgorithmsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListAlgorithms");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListAlgorithmsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListAlgorithmsOutput, _>()
    }

    /// <p>Lists the AppImageConfigs in your account and their properties. The list can be filtered by creation time or modified time, and whether the AppImageConfig name contains a specified string.</p>
    async fn list_app_image_configs(
        &self,
        input: ListAppImageConfigsRequest,
    ) -> Result<ListAppImageConfigsResponse, RusotoError<ListAppImageConfigsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListAppImageConfigs");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListAppImageConfigsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListAppImageConfigsResponse, _>()
    }

    /// <p>Lists apps.</p>
    async fn list_apps(
        &self,
        input: ListAppsRequest,
    ) -> Result<ListAppsResponse, RusotoError<ListAppsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListApps");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListAppsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListAppsResponse, _>()
    }

    /// <p>Lists the artifacts in your account and their properties.</p>
    async fn list_artifacts(
        &self,
        input: ListArtifactsRequest,
    ) -> Result<ListArtifactsResponse, RusotoError<ListArtifactsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListArtifacts");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListArtifactsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListArtifactsResponse, _>()
    }

    /// <p>Lists the associations in your account and their properties.</p>
    async fn list_associations(
        &self,
        input: ListAssociationsRequest,
    ) -> Result<ListAssociationsResponse, RusotoError<ListAssociationsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListAssociations");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListAssociationsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListAssociationsResponse, _>()
    }

    /// <p>Request a list of jobs.</p>
    async fn list_auto_ml_jobs(
        &self,
        input: ListAutoMLJobsRequest,
    ) -> Result<ListAutoMLJobsResponse, RusotoError<ListAutoMLJobsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListAutoMLJobs");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListAutoMLJobsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListAutoMLJobsResponse, _>()
    }

    /// <p>List the Candidates created for the job.</p>
    async fn list_candidates_for_auto_ml_job(
        &self,
        input: ListCandidatesForAutoMLJobRequest,
    ) -> Result<ListCandidatesForAutoMLJobResponse, RusotoError<ListCandidatesForAutoMLJobError>>
    {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListCandidatesForAutoMLJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListCandidatesForAutoMLJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListCandidatesForAutoMLJobResponse, _>()
    }

    /// <p>Gets a list of the Git repositories in your account.</p>
    async fn list_code_repositories(
        &self,
        input: ListCodeRepositoriesInput,
    ) -> Result<ListCodeRepositoriesOutput, RusotoError<ListCodeRepositoriesError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListCodeRepositories");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListCodeRepositoriesError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListCodeRepositoriesOutput, _>()
    }

    /// <p>Lists model compilation jobs that satisfy various filters.</p> <p>To create a model compilation job, use <a>CreateCompilationJob</a>. To get information about a particular model compilation job you have created, use <a>DescribeCompilationJob</a>.</p>
    async fn list_compilation_jobs(
        &self,
        input: ListCompilationJobsRequest,
    ) -> Result<ListCompilationJobsResponse, RusotoError<ListCompilationJobsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListCompilationJobs");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListCompilationJobsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListCompilationJobsResponse, _>()
    }

    /// <p>Lists the contexts in your account and their properties.</p>
    async fn list_contexts(
        &self,
        input: ListContextsRequest,
    ) -> Result<ListContextsResponse, RusotoError<ListContextsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListContexts");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListContextsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListContextsResponse, _>()
    }

    /// <p>Lists the data quality job definitions in your account.</p>
    async fn list_data_quality_job_definitions(
        &self,
        input: ListDataQualityJobDefinitionsRequest,
    ) -> Result<
        ListDataQualityJobDefinitionsResponse,
        RusotoError<ListDataQualityJobDefinitionsError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListDataQualityJobDefinitions");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListDataQualityJobDefinitionsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListDataQualityJobDefinitionsResponse, _>()
    }

    /// <p>Returns a list of devices in the fleet.</p>
    async fn list_device_fleets(
        &self,
        input: ListDeviceFleetsRequest,
    ) -> Result<ListDeviceFleetsResponse, RusotoError<ListDeviceFleetsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListDeviceFleets");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListDeviceFleetsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListDeviceFleetsResponse, _>()
    }

    /// <p>A list of devices.</p>
    async fn list_devices(
        &self,
        input: ListDevicesRequest,
    ) -> Result<ListDevicesResponse, RusotoError<ListDevicesError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListDevices");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListDevicesError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListDevicesResponse, _>()
    }

    /// <p>Lists the domains.</p>
    async fn list_domains(
        &self,
        input: ListDomainsRequest,
    ) -> Result<ListDomainsResponse, RusotoError<ListDomainsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListDomains");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListDomainsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListDomainsResponse, _>()
    }

    /// <p>Returns a list of edge packaging jobs.</p>
    async fn list_edge_packaging_jobs(
        &self,
        input: ListEdgePackagingJobsRequest,
    ) -> Result<ListEdgePackagingJobsResponse, RusotoError<ListEdgePackagingJobsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListEdgePackagingJobs");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListEdgePackagingJobsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListEdgePackagingJobsResponse, _>()
    }

    /// <p>Lists endpoint configurations.</p>
    async fn list_endpoint_configs(
        &self,
        input: ListEndpointConfigsInput,
    ) -> Result<ListEndpointConfigsOutput, RusotoError<ListEndpointConfigsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListEndpointConfigs");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListEndpointConfigsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListEndpointConfigsOutput, _>()
    }

    /// <p>Lists endpoints.</p>
    async fn list_endpoints(
        &self,
        input: ListEndpointsInput,
    ) -> Result<ListEndpointsOutput, RusotoError<ListEndpointsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListEndpoints");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListEndpointsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListEndpointsOutput, _>()
    }

    /// <p>Lists all the experiments in your account. The list can be filtered to show only experiments that were created in a specific time range. The list can be sorted by experiment name or creation time.</p>
    async fn list_experiments(
        &self,
        input: ListExperimentsRequest,
    ) -> Result<ListExperimentsResponse, RusotoError<ListExperimentsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListExperiments");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListExperimentsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListExperimentsResponse, _>()
    }

    /// <p>List <code>FeatureGroup</code>s based on given filter and order.</p>
    async fn list_feature_groups(
        &self,
        input: ListFeatureGroupsRequest,
    ) -> Result<ListFeatureGroupsResponse, RusotoError<ListFeatureGroupsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListFeatureGroups");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListFeatureGroupsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListFeatureGroupsResponse, _>()
    }

    /// <p>Returns information about the flow definitions in your account.</p>
    async fn list_flow_definitions(
        &self,
        input: ListFlowDefinitionsRequest,
    ) -> Result<ListFlowDefinitionsResponse, RusotoError<ListFlowDefinitionsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListFlowDefinitions");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListFlowDefinitionsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListFlowDefinitionsResponse, _>()
    }

    /// <p>Returns information about the human task user interfaces in your account.</p>
    async fn list_human_task_uis(
        &self,
        input: ListHumanTaskUisRequest,
    ) -> Result<ListHumanTaskUisResponse, RusotoError<ListHumanTaskUisError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListHumanTaskUis");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListHumanTaskUisError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListHumanTaskUisResponse, _>()
    }

    /// <p>Gets a list of <a>HyperParameterTuningJobSummary</a> objects that describe the hyperparameter tuning jobs launched in your account.</p>
    async fn list_hyper_parameter_tuning_jobs(
        &self,
        input: ListHyperParameterTuningJobsRequest,
    ) -> Result<ListHyperParameterTuningJobsResponse, RusotoError<ListHyperParameterTuningJobsError>>
    {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListHyperParameterTuningJobs");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListHyperParameterTuningJobsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListHyperParameterTuningJobsResponse, _>()
    }

    /// <p>Lists the versions of a specified image and their properties. The list can be filtered by creation time or modified time.</p>
    async fn list_image_versions(
        &self,
        input: ListImageVersionsRequest,
    ) -> Result<ListImageVersionsResponse, RusotoError<ListImageVersionsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListImageVersions");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListImageVersionsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListImageVersionsResponse, _>()
    }

    /// <p>Lists the images in your account and their properties. The list can be filtered by creation time or modified time, and whether the image name contains a specified string.</p>
    async fn list_images(
        &self,
        input: ListImagesRequest,
    ) -> Result<ListImagesResponse, RusotoError<ListImagesError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListImages");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListImagesError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListImagesResponse, _>()
    }

    /// <p>Gets a list of labeling jobs.</p>
    async fn list_labeling_jobs(
        &self,
        input: ListLabelingJobsRequest,
    ) -> Result<ListLabelingJobsResponse, RusotoError<ListLabelingJobsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListLabelingJobs");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListLabelingJobsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListLabelingJobsResponse, _>()
    }

    /// <p>Gets a list of labeling jobs assigned to a specified work team.</p>
    async fn list_labeling_jobs_for_workteam(
        &self,
        input: ListLabelingJobsForWorkteamRequest,
    ) -> Result<ListLabelingJobsForWorkteamResponse, RusotoError<ListLabelingJobsForWorkteamError>>
    {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListLabelingJobsForWorkteam");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListLabelingJobsForWorkteamError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListLabelingJobsForWorkteamResponse, _>()
    }

    /// <p>Lists model bias jobs definitions that satisfy various filters.</p>
    async fn list_model_bias_job_definitions(
        &self,
        input: ListModelBiasJobDefinitionsRequest,
    ) -> Result<ListModelBiasJobDefinitionsResponse, RusotoError<ListModelBiasJobDefinitionsError>>
    {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListModelBiasJobDefinitions");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListModelBiasJobDefinitionsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListModelBiasJobDefinitionsResponse, _>()
    }

    /// <p>Lists model explainability job definitions that satisfy various filters.</p>
    async fn list_model_explainability_job_definitions(
        &self,
        input: ListModelExplainabilityJobDefinitionsRequest,
    ) -> Result<
        ListModelExplainabilityJobDefinitionsResponse,
        RusotoError<ListModelExplainabilityJobDefinitionsError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.ListModelExplainabilityJobDefinitions",
        );
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                ListModelExplainabilityJobDefinitionsError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListModelExplainabilityJobDefinitionsResponse, _>()
    }

    /// <p>Gets a list of the model groups in your AWS account.</p>
    async fn list_model_package_groups(
        &self,
        input: ListModelPackageGroupsInput,
    ) -> Result<ListModelPackageGroupsOutput, RusotoError<ListModelPackageGroupsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListModelPackageGroups");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListModelPackageGroupsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListModelPackageGroupsOutput, _>()
    }

    /// <p>Lists the model packages that have been created.</p>
    async fn list_model_packages(
        &self,
        input: ListModelPackagesInput,
    ) -> Result<ListModelPackagesOutput, RusotoError<ListModelPackagesError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListModelPackages");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListModelPackagesError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListModelPackagesOutput, _>()
    }

    /// <p>Gets a list of model quality monitoring job definitions in your account.</p>
    async fn list_model_quality_job_definitions(
        &self,
        input: ListModelQualityJobDefinitionsRequest,
    ) -> Result<
        ListModelQualityJobDefinitionsResponse,
        RusotoError<ListModelQualityJobDefinitionsError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListModelQualityJobDefinitions");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListModelQualityJobDefinitionsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListModelQualityJobDefinitionsResponse, _>()
    }

    /// <p>Lists models created with the <a>CreateModel</a> API.</p>
    async fn list_models(
        &self,
        input: ListModelsInput,
    ) -> Result<ListModelsOutput, RusotoError<ListModelsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListModels");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListModelsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListModelsOutput, _>()
    }

    /// <p>Returns list of all monitoring job executions.</p>
    async fn list_monitoring_executions(
        &self,
        input: ListMonitoringExecutionsRequest,
    ) -> Result<ListMonitoringExecutionsResponse, RusotoError<ListMonitoringExecutionsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListMonitoringExecutions");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListMonitoringExecutionsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListMonitoringExecutionsResponse, _>()
    }

    /// <p>Returns list of all monitoring schedules.</p>
    async fn list_monitoring_schedules(
        &self,
        input: ListMonitoringSchedulesRequest,
    ) -> Result<ListMonitoringSchedulesResponse, RusotoError<ListMonitoringSchedulesError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListMonitoringSchedules");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListMonitoringSchedulesError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListMonitoringSchedulesResponse, _>()
    }

    /// <p>Lists notebook instance lifestyle configurations created with the <a>CreateNotebookInstanceLifecycleConfig</a> API.</p>
    async fn list_notebook_instance_lifecycle_configs(
        &self,
        input: ListNotebookInstanceLifecycleConfigsInput,
    ) -> Result<
        ListNotebookInstanceLifecycleConfigsOutput,
        RusotoError<ListNotebookInstanceLifecycleConfigsError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.ListNotebookInstanceLifecycleConfigs",
        );
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                ListNotebookInstanceLifecycleConfigsError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListNotebookInstanceLifecycleConfigsOutput, _>()
    }

    /// <p>Returns a list of the Amazon SageMaker notebook instances in the requester's account in an AWS Region. </p>
    async fn list_notebook_instances(
        &self,
        input: ListNotebookInstancesInput,
    ) -> Result<ListNotebookInstancesOutput, RusotoError<ListNotebookInstancesError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListNotebookInstances");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListNotebookInstancesError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListNotebookInstancesOutput, _>()
    }

    /// <p>Gets a list of <code>PipeLineExecutionStep</code> objects.</p>
    async fn list_pipeline_execution_steps(
        &self,
        input: ListPipelineExecutionStepsRequest,
    ) -> Result<ListPipelineExecutionStepsResponse, RusotoError<ListPipelineExecutionStepsError>>
    {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListPipelineExecutionSteps");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListPipelineExecutionStepsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListPipelineExecutionStepsResponse, _>()
    }

    /// <p>Gets a list of the pipeline executions.</p>
    async fn list_pipeline_executions(
        &self,
        input: ListPipelineExecutionsRequest,
    ) -> Result<ListPipelineExecutionsResponse, RusotoError<ListPipelineExecutionsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListPipelineExecutions");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListPipelineExecutionsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListPipelineExecutionsResponse, _>()
    }

    /// <p>Gets a list of parameters for a pipeline execution.</p>
    async fn list_pipeline_parameters_for_execution(
        &self,
        input: ListPipelineParametersForExecutionRequest,
    ) -> Result<
        ListPipelineParametersForExecutionResponse,
        RusotoError<ListPipelineParametersForExecutionError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.ListPipelineParametersForExecution",
        );
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                ListPipelineParametersForExecutionError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListPipelineParametersForExecutionResponse, _>()
    }

    /// <p>Gets a list of pipelines.</p>
    async fn list_pipelines(
        &self,
        input: ListPipelinesRequest,
    ) -> Result<ListPipelinesResponse, RusotoError<ListPipelinesError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListPipelines");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListPipelinesError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListPipelinesResponse, _>()
    }

    /// <p>Lists processing jobs that satisfy various filters.</p>
    async fn list_processing_jobs(
        &self,
        input: ListProcessingJobsRequest,
    ) -> Result<ListProcessingJobsResponse, RusotoError<ListProcessingJobsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListProcessingJobs");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListProcessingJobsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListProcessingJobsResponse, _>()
    }

    /// <p>Gets a list of the projects in an AWS account.</p>
    async fn list_projects(
        &self,
        input: ListProjectsInput,
    ) -> Result<ListProjectsOutput, RusotoError<ListProjectsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListProjects");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListProjectsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListProjectsOutput, _>()
    }

    /// <p>Gets a list of the work teams that you are subscribed to in the AWS Marketplace. The list may be empty if no work team satisfies the filter specified in the <code>NameContains</code> parameter.</p>
    async fn list_subscribed_workteams(
        &self,
        input: ListSubscribedWorkteamsRequest,
    ) -> Result<ListSubscribedWorkteamsResponse, RusotoError<ListSubscribedWorkteamsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListSubscribedWorkteams");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListSubscribedWorkteamsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListSubscribedWorkteamsResponse, _>()
    }

    /// <p>Returns the tags for the specified Amazon SageMaker resource.</p>
    async fn list_tags(
        &self,
        input: ListTagsInput,
    ) -> Result<ListTagsOutput, RusotoError<ListTagsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListTags");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListTagsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListTagsOutput, _>()
    }

    /// <p>Lists training jobs.</p>
    async fn list_training_jobs(
        &self,
        input: ListTrainingJobsRequest,
    ) -> Result<ListTrainingJobsResponse, RusotoError<ListTrainingJobsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListTrainingJobs");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListTrainingJobsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListTrainingJobsResponse, _>()
    }

    /// <p>Gets a list of <a>TrainingJobSummary</a> objects that describe the training jobs that a hyperparameter tuning job launched.</p>
    async fn list_training_jobs_for_hyper_parameter_tuning_job(
        &self,
        input: ListTrainingJobsForHyperParameterTuningJobRequest,
    ) -> Result<
        ListTrainingJobsForHyperParameterTuningJobResponse,
        RusotoError<ListTrainingJobsForHyperParameterTuningJobError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.ListTrainingJobsForHyperParameterTuningJob",
        );
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                ListTrainingJobsForHyperParameterTuningJobError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<ListTrainingJobsForHyperParameterTuningJobResponse, _>()
    }

    /// <p>Lists transform jobs.</p>
    async fn list_transform_jobs(
        &self,
        input: ListTransformJobsRequest,
    ) -> Result<ListTransformJobsResponse, RusotoError<ListTransformJobsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListTransformJobs");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListTransformJobsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListTransformJobsResponse, _>()
    }

    /// <p><p>Lists the trial components in your account. You can sort the list by trial component name or creation time. You can filter the list to show only components that were created in a specific time range. You can also filter on one of the following:</p> <ul> <li> <p> <code>ExperimentName</code> </p> </li> <li> <p> <code>SourceArn</code> </p> </li> <li> <p> <code>TrialName</code> </p> </li> </ul></p>
    async fn list_trial_components(
        &self,
        input: ListTrialComponentsRequest,
    ) -> Result<ListTrialComponentsResponse, RusotoError<ListTrialComponentsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListTrialComponents");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListTrialComponentsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListTrialComponentsResponse, _>()
    }

    /// <p>Lists the trials in your account. Specify an experiment name to limit the list to the trials that are part of that experiment. Specify a trial component name to limit the list to the trials that associated with that trial component. The list can be filtered to show only trials that were created in a specific time range. The list can be sorted by trial name or creation time.</p>
    async fn list_trials(
        &self,
        input: ListTrialsRequest,
    ) -> Result<ListTrialsResponse, RusotoError<ListTrialsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListTrials");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListTrialsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListTrialsResponse, _>()
    }

    /// <p>Lists user profiles.</p>
    async fn list_user_profiles(
        &self,
        input: ListUserProfilesRequest,
    ) -> Result<ListUserProfilesResponse, RusotoError<ListUserProfilesError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListUserProfiles");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListUserProfilesError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListUserProfilesResponse, _>()
    }

    /// <p>Use this operation to list all private and vendor workforces in an AWS Region. Note that you can only have one private workforce per AWS Region.</p>
    async fn list_workforces(
        &self,
        input: ListWorkforcesRequest,
    ) -> Result<ListWorkforcesResponse, RusotoError<ListWorkforcesError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListWorkforces");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListWorkforcesError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListWorkforcesResponse, _>()
    }

    /// <p>Gets a list of private work teams that you have defined in a region. The list may be empty if no work team satisfies the filter specified in the <code>NameContains</code> parameter.</p>
    async fn list_workteams(
        &self,
        input: ListWorkteamsRequest,
    ) -> Result<ListWorkteamsResponse, RusotoError<ListWorkteamsError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.ListWorkteams");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, ListWorkteamsError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<ListWorkteamsResponse, _>()
    }

    /// <p>Adds a resouce policy to control access to a model group. For information about resoure policies, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html">Identity-based policies and resource-based policies</a> in the <i>AWS Identity and Access Management User Guide.</i>.</p>
    async fn put_model_package_group_policy(
        &self,
        input: PutModelPackageGroupPolicyInput,
    ) -> Result<PutModelPackageGroupPolicyOutput, RusotoError<PutModelPackageGroupPolicyError>>
    {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.PutModelPackageGroupPolicy");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, PutModelPackageGroupPolicyError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<PutModelPackageGroupPolicyOutput, _>()
    }

    /// <p>Register devices.</p>
    async fn register_devices(
        &self,
        input: RegisterDevicesRequest,
    ) -> Result<(), RusotoError<RegisterDevicesError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.RegisterDevices");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, RegisterDevicesError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Renders the UI template so that you can preview the worker's experience. </p>
    async fn render_ui_template(
        &self,
        input: RenderUiTemplateRequest,
    ) -> Result<RenderUiTemplateResponse, RusotoError<RenderUiTemplateError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.RenderUiTemplate");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, RenderUiTemplateError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<RenderUiTemplateResponse, _>()
    }

    /// <p>Finds Amazon SageMaker resources that match a search query. Matching resources are returned as a list of <code>SearchRecord</code> objects in the response. You can sort the search results by any resource property in a ascending or descending order.</p> <p>You can query against the following value types: numeric, text, Boolean, and timestamp.</p>
    async fn search(
        &self,
        input: SearchRequest,
    ) -> Result<SearchResponse, RusotoError<SearchError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.Search");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, SearchError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<SearchResponse, _>()
    }

    /// <p><p>Starts a previously stopped monitoring schedule.</p> <note> <p>By default, when you successfully create a new schedule, the status of a monitoring schedule is <code>scheduled</code>.</p> </note></p>
    async fn start_monitoring_schedule(
        &self,
        input: StartMonitoringScheduleRequest,
    ) -> Result<(), RusotoError<StartMonitoringScheduleError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.StartMonitoringSchedule");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, StartMonitoringScheduleError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Launches an ML compute instance with the latest version of the libraries and attaches your ML storage volume. After configuring the notebook instance, Amazon SageMaker sets the notebook instance status to <code>InService</code>. A notebook instance's status must be <code>InService</code> before you can connect to your Jupyter notebook. </p>
    async fn start_notebook_instance(
        &self,
        input: StartNotebookInstanceInput,
    ) -> Result<(), RusotoError<StartNotebookInstanceError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.StartNotebookInstance");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, StartNotebookInstanceError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Starts a pipeline execution.</p>
    async fn start_pipeline_execution(
        &self,
        input: StartPipelineExecutionRequest,
    ) -> Result<StartPipelineExecutionResponse, RusotoError<StartPipelineExecutionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.StartPipelineExecution");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, StartPipelineExecutionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<StartPipelineExecutionResponse, _>()
    }

    /// <p>A method for forcing the termination of a running job.</p>
    async fn stop_auto_ml_job(
        &self,
        input: StopAutoMLJobRequest,
    ) -> Result<(), RusotoError<StopAutoMLJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.StopAutoMLJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, StopAutoMLJobError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Stops a model compilation job.</p> <p> To stop a job, Amazon SageMaker sends the algorithm the SIGTERM signal. This gracefully shuts the job down. If the job hasn't stopped, it sends the SIGKILL signal.</p> <p>When it receives a <code>StopCompilationJob</code> request, Amazon SageMaker changes the <a>CompilationJobSummary$CompilationJobStatus</a> of the job to <code>Stopping</code>. After Amazon SageMaker stops the job, it sets the <a>CompilationJobSummary$CompilationJobStatus</a> to <code>Stopped</code>. </p>
    async fn stop_compilation_job(
        &self,
        input: StopCompilationJobRequest,
    ) -> Result<(), RusotoError<StopCompilationJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.StopCompilationJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, StopCompilationJobError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Request to stop an edge packaging job.</p>
    async fn stop_edge_packaging_job(
        &self,
        input: StopEdgePackagingJobRequest,
    ) -> Result<(), RusotoError<StopEdgePackagingJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.StopEdgePackagingJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, StopEdgePackagingJobError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Stops a running hyperparameter tuning job and all running training jobs that the tuning job launched.</p> <p>All model artifacts output from the training jobs are stored in Amazon Simple Storage Service (Amazon S3). All data that the training jobs write to Amazon CloudWatch Logs are still available in CloudWatch. After the tuning job moves to the <code>Stopped</code> state, it releases all reserved resources for the tuning job.</p>
    async fn stop_hyper_parameter_tuning_job(
        &self,
        input: StopHyperParameterTuningJobRequest,
    ) -> Result<(), RusotoError<StopHyperParameterTuningJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.StopHyperParameterTuningJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, StopHyperParameterTuningJobError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Stops a running labeling job. A job that is stopped cannot be restarted. Any results obtained before the job is stopped are placed in the Amazon S3 output bucket.</p>
    async fn stop_labeling_job(
        &self,
        input: StopLabelingJobRequest,
    ) -> Result<(), RusotoError<StopLabelingJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.StopLabelingJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, StopLabelingJobError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Stops a previously started monitoring schedule.</p>
    async fn stop_monitoring_schedule(
        &self,
        input: StopMonitoringScheduleRequest,
    ) -> Result<(), RusotoError<StopMonitoringScheduleError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.StopMonitoringSchedule");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, StopMonitoringScheduleError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Terminates the ML compute instance. Before terminating the instance, Amazon SageMaker disconnects the ML storage volume from it. Amazon SageMaker preserves the ML storage volume. Amazon SageMaker stops charging you for the ML compute instance when you call <code>StopNotebookInstance</code>.</p> <p>To access data on the ML storage volume for a notebook instance that has been terminated, call the <code>StartNotebookInstance</code> API. <code>StartNotebookInstance</code> launches another ML compute instance, configures it, and attaches the preserved ML storage volume so you can continue your work. </p>
    async fn stop_notebook_instance(
        &self,
        input: StopNotebookInstanceInput,
    ) -> Result<(), RusotoError<StopNotebookInstanceError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.StopNotebookInstance");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, StopNotebookInstanceError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Stops a pipeline execution.</p>
    async fn stop_pipeline_execution(
        &self,
        input: StopPipelineExecutionRequest,
    ) -> Result<StopPipelineExecutionResponse, RusotoError<StopPipelineExecutionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.StopPipelineExecution");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, StopPipelineExecutionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<StopPipelineExecutionResponse, _>()
    }

    /// <p>Stops a processing job.</p>
    async fn stop_processing_job(
        &self,
        input: StopProcessingJobRequest,
    ) -> Result<(), RusotoError<StopProcessingJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.StopProcessingJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, StopProcessingJobError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Stops a training job. To stop a job, Amazon SageMaker sends the algorithm the <code>SIGTERM</code> signal, which delays job termination for 120 seconds. Algorithms might use this 120-second window to save the model artifacts, so the results of the training is not lost. </p> <p>When it receives a <code>StopTrainingJob</code> request, Amazon SageMaker changes the status of the job to <code>Stopping</code>. After Amazon SageMaker stops the job, it sets the status to <code>Stopped</code>.</p>
    async fn stop_training_job(
        &self,
        input: StopTrainingJobRequest,
    ) -> Result<(), RusotoError<StopTrainingJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.StopTrainingJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, StopTrainingJobError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Stops a transform job.</p> <p>When Amazon SageMaker receives a <code>StopTransformJob</code> request, the status of the job changes to <code>Stopping</code>. After Amazon SageMaker stops the job, the status is set to <code>Stopped</code>. When you stop a transform job before it is completed, Amazon SageMaker doesn't store the job's output in Amazon S3.</p>
    async fn stop_transform_job(
        &self,
        input: StopTransformJobRequest,
    ) -> Result<(), RusotoError<StopTransformJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.StopTransformJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, StopTransformJobError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Updates an action.</p>
    async fn update_action(
        &self,
        input: UpdateActionRequest,
    ) -> Result<UpdateActionResponse, RusotoError<UpdateActionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateAction");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateActionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<UpdateActionResponse, _>()
    }

    /// <p>Updates the properties of an AppImageConfig.</p>
    async fn update_app_image_config(
        &self,
        input: UpdateAppImageConfigRequest,
    ) -> Result<UpdateAppImageConfigResponse, RusotoError<UpdateAppImageConfigError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateAppImageConfig");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateAppImageConfigError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<UpdateAppImageConfigResponse, _>()
    }

    /// <p>Updates an artifact.</p>
    async fn update_artifact(
        &self,
        input: UpdateArtifactRequest,
    ) -> Result<UpdateArtifactResponse, RusotoError<UpdateArtifactError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateArtifact");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateArtifactError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<UpdateArtifactResponse, _>()
    }

    /// <p>Updates the specified Git repository with the specified values.</p>
    async fn update_code_repository(
        &self,
        input: UpdateCodeRepositoryInput,
    ) -> Result<UpdateCodeRepositoryOutput, RusotoError<UpdateCodeRepositoryError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateCodeRepository");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateCodeRepositoryError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<UpdateCodeRepositoryOutput, _>()
    }

    /// <p>Updates a context.</p>
    async fn update_context(
        &self,
        input: UpdateContextRequest,
    ) -> Result<UpdateContextResponse, RusotoError<UpdateContextError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateContext");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateContextError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<UpdateContextResponse, _>()
    }

    /// <p>Updates a fleet of devices.</p>
    async fn update_device_fleet(
        &self,
        input: UpdateDeviceFleetRequest,
    ) -> Result<(), RusotoError<UpdateDeviceFleetError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateDeviceFleet");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateDeviceFleetError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Updates one or more devices in a fleet.</p>
    async fn update_devices(
        &self,
        input: UpdateDevicesRequest,
    ) -> Result<(), RusotoError<UpdateDevicesError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateDevices");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateDevicesError::from_response)
            .await?;
        std::mem::drop(response);
        Ok(())
    }

    /// <p>Updates the default settings for new user profiles in the domain.</p>
    async fn update_domain(
        &self,
        input: UpdateDomainRequest,
    ) -> Result<UpdateDomainResponse, RusotoError<UpdateDomainError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateDomain");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateDomainError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<UpdateDomainResponse, _>()
    }

    /// <p><p>Deploys the new <code>EndpointConfig</code> specified in the request, switches to using newly created endpoint, and then deletes resources provisioned for the endpoint using the previous <code>EndpointConfig</code> (there is no availability loss). </p> <p>When Amazon SageMaker receives the request, it sets the endpoint status to <code>Updating</code>. After updating the endpoint, it sets the status to <code>InService</code>. To check the status of an endpoint, use the <a>DescribeEndpoint</a> API. </p> <note> <p>You must not delete an <code>EndpointConfig</code> in use by an endpoint that is live or while the <code>UpdateEndpoint</code> or <code>CreateEndpoint</code> operations are being performed on the endpoint. To update an endpoint, you must create a new <code>EndpointConfig</code>.</p> <p>If you delete the <code>EndpointConfig</code> of an endpoint that is active or being created or updated you may lose visibility into the instance type the endpoint is using. The endpoint must be deleted in order to stop incurring charges.</p> </note></p>
    async fn update_endpoint(
        &self,
        input: UpdateEndpointInput,
    ) -> Result<UpdateEndpointOutput, RusotoError<UpdateEndpointError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateEndpoint");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateEndpointError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<UpdateEndpointOutput, _>()
    }

    /// <p>Updates variant weight of one or more variants associated with an existing endpoint, or capacity of one variant associated with an existing endpoint. When it receives the request, Amazon SageMaker sets the endpoint status to <code>Updating</code>. After updating the endpoint, it sets the status to <code>InService</code>. To check the status of an endpoint, use the <a>DescribeEndpoint</a> API. </p>
    async fn update_endpoint_weights_and_capacities(
        &self,
        input: UpdateEndpointWeightsAndCapacitiesInput,
    ) -> Result<
        UpdateEndpointWeightsAndCapacitiesOutput,
        RusotoError<UpdateEndpointWeightsAndCapacitiesError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.UpdateEndpointWeightsAndCapacities",
        );
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                UpdateEndpointWeightsAndCapacitiesError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<UpdateEndpointWeightsAndCapacitiesOutput, _>()
    }

    /// <p>Adds, updates, or removes the description of an experiment. Updates the display name of an experiment.</p>
    async fn update_experiment(
        &self,
        input: UpdateExperimentRequest,
    ) -> Result<UpdateExperimentResponse, RusotoError<UpdateExperimentError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateExperiment");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateExperimentError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<UpdateExperimentResponse, _>()
    }

    /// <p>Updates the properties of a SageMaker image. To change the image's tags, use the <a>AddTags</a> and <a>DeleteTags</a> APIs.</p>
    async fn update_image(
        &self,
        input: UpdateImageRequest,
    ) -> Result<UpdateImageResponse, RusotoError<UpdateImageError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateImage");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateImageError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<UpdateImageResponse, _>()
    }

    /// <p>Updates a versioned model.</p>
    async fn update_model_package(
        &self,
        input: UpdateModelPackageInput,
    ) -> Result<UpdateModelPackageOutput, RusotoError<UpdateModelPackageError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateModelPackage");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateModelPackageError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<UpdateModelPackageOutput, _>()
    }

    /// <p>Updates a previously created schedule.</p>
    async fn update_monitoring_schedule(
        &self,
        input: UpdateMonitoringScheduleRequest,
    ) -> Result<UpdateMonitoringScheduleResponse, RusotoError<UpdateMonitoringScheduleError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateMonitoringSchedule");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateMonitoringScheduleError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<UpdateMonitoringScheduleResponse, _>()
    }

    /// <p>Updates a notebook instance. NotebookInstance updates include upgrading or downgrading the ML compute instance used for your notebook instance to accommodate changes in your workload requirements.</p>
    async fn update_notebook_instance(
        &self,
        input: UpdateNotebookInstanceInput,
    ) -> Result<UpdateNotebookInstanceOutput, RusotoError<UpdateNotebookInstanceError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateNotebookInstance");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateNotebookInstanceError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<UpdateNotebookInstanceOutput, _>()
    }

    /// <p>Updates a notebook instance lifecycle configuration created with the <a>CreateNotebookInstanceLifecycleConfig</a> API.</p>
    async fn update_notebook_instance_lifecycle_config(
        &self,
        input: UpdateNotebookInstanceLifecycleConfigInput,
    ) -> Result<
        UpdateNotebookInstanceLifecycleConfigOutput,
        RusotoError<UpdateNotebookInstanceLifecycleConfigError>,
    > {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header(
            "x-amz-target",
            "SageMaker.UpdateNotebookInstanceLifecycleConfig",
        );
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(
                request,
                UpdateNotebookInstanceLifecycleConfigError::from_response,
            )
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<UpdateNotebookInstanceLifecycleConfigOutput, _>()
    }

    /// <p>Updates a pipeline.</p>
    async fn update_pipeline(
        &self,
        input: UpdatePipelineRequest,
    ) -> Result<UpdatePipelineResponse, RusotoError<UpdatePipelineError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdatePipeline");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdatePipelineError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<UpdatePipelineResponse, _>()
    }

    /// <p>Updates a pipeline execution.</p>
    async fn update_pipeline_execution(
        &self,
        input: UpdatePipelineExecutionRequest,
    ) -> Result<UpdatePipelineExecutionResponse, RusotoError<UpdatePipelineExecutionError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdatePipelineExecution");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdatePipelineExecutionError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<UpdatePipelineExecutionResponse, _>()
    }

    /// <p>Update a model training job to request a new Debugger profiling configuration.</p>
    async fn update_training_job(
        &self,
        input: UpdateTrainingJobRequest,
    ) -> Result<UpdateTrainingJobResponse, RusotoError<UpdateTrainingJobError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateTrainingJob");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateTrainingJobError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<UpdateTrainingJobResponse, _>()
    }

    /// <p>Updates the display name of a trial.</p>
    async fn update_trial(
        &self,
        input: UpdateTrialRequest,
    ) -> Result<UpdateTrialResponse, RusotoError<UpdateTrialError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateTrial");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateTrialError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<UpdateTrialResponse, _>()
    }

    /// <p>Updates one or more properties of a trial component.</p>
    async fn update_trial_component(
        &self,
        input: UpdateTrialComponentRequest,
    ) -> Result<UpdateTrialComponentResponse, RusotoError<UpdateTrialComponentError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateTrialComponent");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateTrialComponentError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response)
            .deserialize::<UpdateTrialComponentResponse, _>()
    }

    /// <p>Updates a user profile.</p>
    async fn update_user_profile(
        &self,
        input: UpdateUserProfileRequest,
    ) -> Result<UpdateUserProfileResponse, RusotoError<UpdateUserProfileError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateUserProfile");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateUserProfileError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<UpdateUserProfileResponse, _>()
    }

    /// <p><p>Use this operation to update your workforce. You can use this operation to require that workers use specific IP addresses to work on tasks and to update your OpenID Connect (OIDC) Identity Provider (IdP) workforce configuration.</p> <p> Use <code>SourceIpConfig</code> to restrict worker access to tasks to a specific range of IP addresses. You specify allowed IP addresses by creating a list of up to ten <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html">CIDRs</a>. By default, a workforce isn&#39;t restricted to specific IP addresses. If you specify a range of IP addresses, workers who attempt to access tasks using any IP address outside the specified range are denied and get a <code>Not Found</code> error message on the worker portal.</p> <p>Use <code>OidcConfig</code> to update the configuration of a workforce created using your own OIDC IdP. </p> <important> <p>You can only update your OIDC IdP configuration when there are no work teams associated with your workforce. You can delete work teams using the operation.</p> </important> <p>After restricting access to a range of IP addresses or updating your OIDC IdP configuration with this operation, you can view details about your update workforce using the operation.</p> <important> <p>This operation only applies to private workforces.</p> </important></p>
    async fn update_workforce(
        &self,
        input: UpdateWorkforceRequest,
    ) -> Result<UpdateWorkforceResponse, RusotoError<UpdateWorkforceError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateWorkforce");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateWorkforceError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<UpdateWorkforceResponse, _>()
    }

    /// <p>Updates an existing work team with new member definitions or description.</p>
    async fn update_workteam(
        &self,
        input: UpdateWorkteamRequest,
    ) -> Result<UpdateWorkteamResponse, RusotoError<UpdateWorkteamError>> {
        let mut request = self.new_signed_request("POST", "/");
        request.add_header("x-amz-target", "SageMaker.UpdateWorkteam");
        let encoded = serde_json::to_string(&input).unwrap();
        request.set_payload(Some(encoded));

        let response = self
            .sign_and_dispatch(request, UpdateWorkteamError::from_response)
            .await?;
        let mut response = response;
        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
        proto::json::ResponsePayload::new(&response).deserialize::<UpdateWorkteamResponse, _>()
    }
}