api.go

// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.

package sagemaker

import (
	"fmt"
	"time"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/internal/awsutil"
	"github.com/aws/aws-sdk-go-v2/private/protocol"
	"github.com/aws/aws-sdk-go-v2/private/protocol/jsonrpc"
)

const opAddTags = "AddTags"

// AddTagsRequest is a API request type for the AddTags API operation.
type AddTagsRequest struct {
	*aws.Request
	Input *AddTagsInput
	Copy  func(*AddTagsInput) AddTagsRequest
}

// Send marshals and sends the AddTags API request.
func (r AddTagsRequest) Send() (*AddTagsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*AddTagsOutput), nil
}

// AddTagsRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Adds or overwrites one or more tags for the specified Amazon SageMaker resource.
// You can add tags to notebook instances, training jobs, models, endpoint configurations,
// and endpoints.
//
// Each tag consists of a key and an optional value. Tag keys must be unique
// per resource. For more information about tags, see Using Cost Allocation
// Tags (http://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-what)
// in the AWS Billing and Cost Management User Guide.
//
//    // Example sending a request using the AddTagsRequest method.
//    req := client.AddTagsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/AddTags
func (c *SageMaker) AddTagsRequest(input *AddTagsInput) AddTagsRequest {
	op := &aws.Operation{
		Name:       opAddTags,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AddTagsInput{}
	}

	output := &AddTagsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return AddTagsRequest{Request: req, Input: input, Copy: c.AddTagsRequest}
}

const opCreateEndpoint = "CreateEndpoint"

// CreateEndpointRequest is a API request type for the CreateEndpoint API operation.
type CreateEndpointRequest struct {
	*aws.Request
	Input *CreateEndpointInput
	Copy  func(*CreateEndpointInput) CreateEndpointRequest
}

// Send marshals and sends the CreateEndpoint API request.
func (r CreateEndpointRequest) Send() (*CreateEndpointOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateEndpointOutput), nil
}

// CreateEndpointRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// 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 CreateEndpointConfig (http://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateEndpointConfig.html)
// API.
//
// Use this API only for hosting models using Amazon SageMaker hosting services.
//
// The endpoint name must be unique within an AWS Region in your AWS account.
//
// When it receives the request, Amazon SageMaker creates the endpoint, launches
// the resources (ML compute instances), and deploys the model(s) on them.
//
// When Amazon SageMaker receives the request, it sets the endpoint status to
// Creating. After it creates the endpoint, it sets the status to InService.
// Amazon SageMaker can then process incoming requests for inferences. To check
// the status of an endpoint, use the DescribeEndpoint (http://docs.aws.amazon.com/sagemaker/latest/dg/API_DescribeEndpoint.html)
// API.
//
// For an example, see Exercise 1: Using the K-Means Algorithm Provided by Amazon
// SageMaker (http://docs.aws.amazon.com/sagemaker/latest/dg/ex1.html).
//
//    // Example sending a request using the CreateEndpointRequest method.
//    req := client.CreateEndpointRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateEndpoint
func (c *SageMaker) CreateEndpointRequest(input *CreateEndpointInput) CreateEndpointRequest {
	op := &aws.Operation{
		Name:       opCreateEndpoint,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateEndpointInput{}
	}

	output := &CreateEndpointOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateEndpointRequest{Request: req, Input: input, Copy: c.CreateEndpointRequest}
}

const opCreateEndpointConfig = "CreateEndpointConfig"

// CreateEndpointConfigRequest is a API request type for the CreateEndpointConfig API operation.
type CreateEndpointConfigRequest struct {
	*aws.Request
	Input *CreateEndpointConfigInput
	Copy  func(*CreateEndpointConfigInput) CreateEndpointConfigRequest
}

// Send marshals and sends the CreateEndpointConfig API request.
func (r CreateEndpointConfigRequest) Send() (*CreateEndpointConfigOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateEndpointConfigOutput), nil
}

// CreateEndpointConfigRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// 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 CreateModel API, to deploy and the resources that you want
// Amazon SageMaker to provision. Then you call the CreateEndpoint (http://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateEndpoint.html)
// API.
//
// Use this API only if you want to use Amazon SageMaker hosting services to
// deploy models into production.
//
// In the request, you define one or more ProductionVariants, each of which
// identifies a model. Each ProductionVariant parameter also describes the resources
// that you want Amazon SageMaker to provision. This includes the number and
// type of ML compute instances to deploy.
//
// If you are hosting multiple models, you also assign a VariantWeight 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.
//
//    // Example sending a request using the CreateEndpointConfigRequest method.
//    req := client.CreateEndpointConfigRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateEndpointConfig
func (c *SageMaker) CreateEndpointConfigRequest(input *CreateEndpointConfigInput) CreateEndpointConfigRequest {
	op := &aws.Operation{
		Name:       opCreateEndpointConfig,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateEndpointConfigInput{}
	}

	output := &CreateEndpointConfigOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateEndpointConfigRequest{Request: req, Input: input, Copy: c.CreateEndpointConfigRequest}
}

const opCreateModel = "CreateModel"

// CreateModelRequest is a API request type for the CreateModel API operation.
type CreateModelRequest struct {
	*aws.Request
	Input *CreateModelInput
	Copy  func(*CreateModelInput) CreateModelRequest
}

// Send marshals and sends the CreateModel API request.
func (r CreateModelRequest) Send() (*CreateModelOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateModelOutput), nil
}

// CreateModelRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Creates a model in Amazon SageMaker. In the request, you name the model and
// describe one or more containers. For each container, you specify the docker
// image containing inference code, artifacts (from prior training), and custom
// environment map that the inference code uses when you deploy the model into
// production.
//
// Use this API to create a model only if you want to use Amazon SageMaker hosting
// services. To host your model, you create an endpoint configuration with the
// CreateEndpointConfig API, and then create an endpoint with the CreateEndpoint
// API.
//
// Amazon SageMaker then deploys all of the containers that you defined for
// the model in the hosting environment.
//
// In the CreateModel request, you must define a container with the PrimaryContainer
// parameter.
//
// 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. 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.
//
//    // Example sending a request using the CreateModelRequest method.
//    req := client.CreateModelRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateModel
func (c *SageMaker) CreateModelRequest(input *CreateModelInput) CreateModelRequest {
	op := &aws.Operation{
		Name:       opCreateModel,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateModelInput{}
	}

	output := &CreateModelOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateModelRequest{Request: req, Input: input, Copy: c.CreateModelRequest}
}

const opCreateNotebookInstance = "CreateNotebookInstance"

// CreateNotebookInstanceRequest is a API request type for the CreateNotebookInstance API operation.
type CreateNotebookInstanceRequest struct {
	*aws.Request
	Input *CreateNotebookInstanceInput
	Copy  func(*CreateNotebookInstanceInput) CreateNotebookInstanceRequest
}

// Send marshals and sends the CreateNotebookInstance API request.
func (r CreateNotebookInstanceRequest) Send() (*CreateNotebookInstanceOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateNotebookInstanceOutput), nil
}

// CreateNotebookInstanceRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Creates an Amazon SageMaker notebook instance. A notebook instance is a machine
// learning (ML) compute instance running on a Jupyter notebook.
//
// In a CreateNotebookInstance 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.
//
// 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.
//
// After receiving the request, Amazon SageMaker does the following:
//
// Creates a network interface in the Amazon SageMaker VPC.
//
// (Option) If you specified SubnetId, 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.
//
// Launches an EC2 instance of the type specified in the request in the Amazon
// SageMaker VPC. If you specified SubnetId 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.
//
// After creating the notebook instance, Amazon SageMaker returns its Amazon
// Resource Name (ARN).
//
// 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.
//
// For more information, see How It Works (http://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works.html).
//
//    // Example sending a request using the CreateNotebookInstanceRequest method.
//    req := client.CreateNotebookInstanceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateNotebookInstance
func (c *SageMaker) CreateNotebookInstanceRequest(input *CreateNotebookInstanceInput) CreateNotebookInstanceRequest {
	op := &aws.Operation{
		Name:       opCreateNotebookInstance,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateNotebookInstanceInput{}
	}

	output := &CreateNotebookInstanceOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateNotebookInstanceRequest{Request: req, Input: input, Copy: c.CreateNotebookInstanceRequest}
}

const opCreateNotebookInstanceLifecycleConfig = "CreateNotebookInstanceLifecycleConfig"

// CreateNotebookInstanceLifecycleConfigRequest is a API request type for the CreateNotebookInstanceLifecycleConfig API operation.
type CreateNotebookInstanceLifecycleConfigRequest struct {
	*aws.Request
	Input *CreateNotebookInstanceLifecycleConfigInput
	Copy  func(*CreateNotebookInstanceLifecycleConfigInput) CreateNotebookInstanceLifecycleConfigRequest
}

// Send marshals and sends the CreateNotebookInstanceLifecycleConfig API request.
func (r CreateNotebookInstanceLifecycleConfigRequest) Send() (*CreateNotebookInstanceLifecycleConfigOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateNotebookInstanceLifecycleConfigOutput), nil
}

// CreateNotebookInstanceLifecycleConfigRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Creates a lifecycle configuration that you can associate with a notebook
// instance. A lifecycle configuration is a collection of shell scripts that
// run when you create or start a notebook instance.
//
// Each lifecycle configuration script has a limit of 16384 characters.
//
// The value of the $PATH environment variable that is available to both scripts
// is /sbin:bin:/usr/sbin:/usr/bin.
//
// View CloudWatch Logs for notebook instance lifecycle configurations in log
// group /aws/sagemaker/NotebookInstances in log stream [notebook-instance-name]/[LifecycleConfigHook].
//
// Lifecycle configuration scripts cannot run for longer than 5 minutes. If
// a script runs for longer than 5 minutes, it fails and the notebook instance
// is not created or started.
//
// For information about notebook instance lifestyle configurations, see notebook-lifecycle-config.
//
//    // Example sending a request using the CreateNotebookInstanceLifecycleConfigRequest method.
//    req := client.CreateNotebookInstanceLifecycleConfigRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateNotebookInstanceLifecycleConfig
func (c *SageMaker) CreateNotebookInstanceLifecycleConfigRequest(input *CreateNotebookInstanceLifecycleConfigInput) CreateNotebookInstanceLifecycleConfigRequest {
	op := &aws.Operation{
		Name:       opCreateNotebookInstanceLifecycleConfig,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateNotebookInstanceLifecycleConfigInput{}
	}

	output := &CreateNotebookInstanceLifecycleConfigOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateNotebookInstanceLifecycleConfigRequest{Request: req, Input: input, Copy: c.CreateNotebookInstanceLifecycleConfigRequest}
}

const opCreatePresignedNotebookInstanceUrl = "CreatePresignedNotebookInstanceUrl"

// CreatePresignedNotebookInstanceUrlRequest is a API request type for the CreatePresignedNotebookInstanceUrl API operation.
type CreatePresignedNotebookInstanceUrlRequest struct {
	*aws.Request
	Input *CreatePresignedNotebookInstanceUrlInput
	Copy  func(*CreatePresignedNotebookInstanceUrlInput) CreatePresignedNotebookInstanceUrlRequest
}

// Send marshals and sends the CreatePresignedNotebookInstanceUrl API request.
func (r CreatePresignedNotebookInstanceUrlRequest) Send() (*CreatePresignedNotebookInstanceUrlOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreatePresignedNotebookInstanceUrlOutput), nil
}

// CreatePresignedNotebookInstanceUrlRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Returns a URL that you can use to connect to the Juypter server from a notebook
// instance. In the Amazon SageMaker console, when you choose Open 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.
//
//    // Example sending a request using the CreatePresignedNotebookInstanceUrlRequest method.
//    req := client.CreatePresignedNotebookInstanceUrlRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreatePresignedNotebookInstanceUrl
func (c *SageMaker) CreatePresignedNotebookInstanceUrlRequest(input *CreatePresignedNotebookInstanceUrlInput) CreatePresignedNotebookInstanceUrlRequest {
	op := &aws.Operation{
		Name:       opCreatePresignedNotebookInstanceUrl,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreatePresignedNotebookInstanceUrlInput{}
	}

	output := &CreatePresignedNotebookInstanceUrlOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreatePresignedNotebookInstanceUrlRequest{Request: req, Input: input, Copy: c.CreatePresignedNotebookInstanceUrlRequest}
}

const opCreateTrainingJob = "CreateTrainingJob"

// CreateTrainingJobRequest is a API request type for the CreateTrainingJob API operation.
type CreateTrainingJobRequest struct {
	*aws.Request
	Input *CreateTrainingJobInput
	Copy  func(*CreateTrainingJobInput) CreateTrainingJobRequest
}

// Send marshals and sends the CreateTrainingJob API request.
func (r CreateTrainingJobRequest) Send() (*CreateTrainingJobOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateTrainingJobOutput), nil
}

// CreateTrainingJobRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Starts a model training job. After training completes, Amazon SageMaker saves
// the resulting model artifacts to an Amazon S3 location that you specify.
//
// 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 deep learning service other than Amazon SageMaker,
// provided that you know how to use them for inferences.
//
// In the request body, you provide the following:
//
//    * AlgorithmSpecification - Identifies the training algorithm to use.
//
//    * HyperParameters - Specify these algorithm-specific parameters to influence
//    the quality of the final model. For a list of hyperparameters for each
//    training algorithm provided by Amazon SageMaker, see Algorithms (http://docs.aws.amazon.com/sagemaker/latest/dg/algos.html).
//
//
//    * InputDataConfig - Describes the training dataset and the Amazon S3 location
//    where it is stored.
//
//    * OutputDataConfig - Identifies the Amazon S3 location where you want
//    Amazon SageMaker to save the results of model training.
//
//    * ResourceConfig - Identifies the resources, ML compute instances, and
//    ML storage volumes to deploy for model training. In distributed training,
//    you specify more than one instance.
//
//    * RoleARN - 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.
//
//    * StoppingCondition - Sets a duration for training. Use this parameter
//    to cap model training costs.
//
//  For more information about Amazon SageMaker, see How It Works (http://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works.html)
//
//    // Example sending a request using the CreateTrainingJobRequest method.
//    req := client.CreateTrainingJobRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateTrainingJob
func (c *SageMaker) CreateTrainingJobRequest(input *CreateTrainingJobInput) CreateTrainingJobRequest {
	op := &aws.Operation{
		Name:       opCreateTrainingJob,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateTrainingJobInput{}
	}

	output := &CreateTrainingJobOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateTrainingJobRequest{Request: req, Input: input, Copy: c.CreateTrainingJobRequest}
}

const opDeleteEndpoint = "DeleteEndpoint"

// DeleteEndpointRequest is a API request type for the DeleteEndpoint API operation.
type DeleteEndpointRequest struct {
	*aws.Request
	Input *DeleteEndpointInput
	Copy  func(*DeleteEndpointInput) DeleteEndpointRequest
}

// Send marshals and sends the DeleteEndpoint API request.
func (r DeleteEndpointRequest) Send() (*DeleteEndpointOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteEndpointOutput), nil
}

// DeleteEndpointRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Deletes an endpoint. Amazon SageMaker frees up all of the resources that
// were deployed when the endpoint was created.
//
//    // Example sending a request using the DeleteEndpointRequest method.
//    req := client.DeleteEndpointRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteEndpoint
func (c *SageMaker) DeleteEndpointRequest(input *DeleteEndpointInput) DeleteEndpointRequest {
	op := &aws.Operation{
		Name:       opDeleteEndpoint,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteEndpointInput{}
	}

	output := &DeleteEndpointOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteEndpointRequest{Request: req, Input: input, Copy: c.DeleteEndpointRequest}
}

const opDeleteEndpointConfig = "DeleteEndpointConfig"

// DeleteEndpointConfigRequest is a API request type for the DeleteEndpointConfig API operation.
type DeleteEndpointConfigRequest struct {
	*aws.Request
	Input *DeleteEndpointConfigInput
	Copy  func(*DeleteEndpointConfigInput) DeleteEndpointConfigRequest
}

// Send marshals and sends the DeleteEndpointConfig API request.
func (r DeleteEndpointConfigRequest) Send() (*DeleteEndpointConfigOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteEndpointConfigOutput), nil
}

// DeleteEndpointConfigRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Deletes an endpoint configuration. The DeleteEndpoingConfig API deletes only
// the specified configuration. It does not delete endpoints created using the
// configuration.
//
//    // Example sending a request using the DeleteEndpointConfigRequest method.
//    req := client.DeleteEndpointConfigRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteEndpointConfig
func (c *SageMaker) DeleteEndpointConfigRequest(input *DeleteEndpointConfigInput) DeleteEndpointConfigRequest {
	op := &aws.Operation{
		Name:       opDeleteEndpointConfig,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteEndpointConfigInput{}
	}

	output := &DeleteEndpointConfigOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteEndpointConfigRequest{Request: req, Input: input, Copy: c.DeleteEndpointConfigRequest}
}

const opDeleteModel = "DeleteModel"

// DeleteModelRequest is a API request type for the DeleteModel API operation.
type DeleteModelRequest struct {
	*aws.Request
	Input *DeleteModelInput
	Copy  func(*DeleteModelInput) DeleteModelRequest
}

// Send marshals and sends the DeleteModel API request.
func (r DeleteModelRequest) Send() (*DeleteModelOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteModelOutput), nil
}

// DeleteModelRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Deletes a model. The DeleteModel API deletes only the model entry that was
// created in Amazon SageMaker when you called the CreateModel (http://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateModel.html)
// API. It does not delete model artifacts, inference code, or the IAM role
// that you specified when creating the model.
//
//    // Example sending a request using the DeleteModelRequest method.
//    req := client.DeleteModelRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteModel
func (c *SageMaker) DeleteModelRequest(input *DeleteModelInput) DeleteModelRequest {
	op := &aws.Operation{
		Name:       opDeleteModel,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteModelInput{}
	}

	output := &DeleteModelOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteModelRequest{Request: req, Input: input, Copy: c.DeleteModelRequest}
}

const opDeleteNotebookInstance = "DeleteNotebookInstance"

// DeleteNotebookInstanceRequest is a API request type for the DeleteNotebookInstance API operation.
type DeleteNotebookInstanceRequest struct {
	*aws.Request
	Input *DeleteNotebookInstanceInput
	Copy  func(*DeleteNotebookInstanceInput) DeleteNotebookInstanceRequest
}

// Send marshals and sends the DeleteNotebookInstance API request.
func (r DeleteNotebookInstanceRequest) Send() (*DeleteNotebookInstanceOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteNotebookInstanceOutput), nil
}

// DeleteNotebookInstanceRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Deletes an Amazon SageMaker notebook instance. Before you can delete a notebook
// instance, you must call the StopNotebookInstance API.
//
// 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.
//
//    // Example sending a request using the DeleteNotebookInstanceRequest method.
//    req := client.DeleteNotebookInstanceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteNotebookInstance
func (c *SageMaker) DeleteNotebookInstanceRequest(input *DeleteNotebookInstanceInput) DeleteNotebookInstanceRequest {
	op := &aws.Operation{
		Name:       opDeleteNotebookInstance,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteNotebookInstanceInput{}
	}

	output := &DeleteNotebookInstanceOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteNotebookInstanceRequest{Request: req, Input: input, Copy: c.DeleteNotebookInstanceRequest}
}

const opDeleteNotebookInstanceLifecycleConfig = "DeleteNotebookInstanceLifecycleConfig"

// DeleteNotebookInstanceLifecycleConfigRequest is a API request type for the DeleteNotebookInstanceLifecycleConfig API operation.
type DeleteNotebookInstanceLifecycleConfigRequest struct {
	*aws.Request
	Input *DeleteNotebookInstanceLifecycleConfigInput
	Copy  func(*DeleteNotebookInstanceLifecycleConfigInput) DeleteNotebookInstanceLifecycleConfigRequest
}

// Send marshals and sends the DeleteNotebookInstanceLifecycleConfig API request.
func (r DeleteNotebookInstanceLifecycleConfigRequest) Send() (*DeleteNotebookInstanceLifecycleConfigOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteNotebookInstanceLifecycleConfigOutput), nil
}

// DeleteNotebookInstanceLifecycleConfigRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Deletes a notebook instance lifecycle configuration.
//
//    // Example sending a request using the DeleteNotebookInstanceLifecycleConfigRequest method.
//    req := client.DeleteNotebookInstanceLifecycleConfigRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteNotebookInstanceLifecycleConfig
func (c *SageMaker) DeleteNotebookInstanceLifecycleConfigRequest(input *DeleteNotebookInstanceLifecycleConfigInput) DeleteNotebookInstanceLifecycleConfigRequest {
	op := &aws.Operation{
		Name:       opDeleteNotebookInstanceLifecycleConfig,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteNotebookInstanceLifecycleConfigInput{}
	}

	output := &DeleteNotebookInstanceLifecycleConfigOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteNotebookInstanceLifecycleConfigRequest{Request: req, Input: input, Copy: c.DeleteNotebookInstanceLifecycleConfigRequest}
}

const opDeleteTags = "DeleteTags"

// DeleteTagsRequest is a API request type for the DeleteTags API operation.
type DeleteTagsRequest struct {
	*aws.Request
	Input *DeleteTagsInput
	Copy  func(*DeleteTagsInput) DeleteTagsRequest
}

// Send marshals and sends the DeleteTags API request.
func (r DeleteTagsRequest) Send() (*DeleteTagsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteTagsOutput), nil
}

// DeleteTagsRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Deletes the specified tags from an Amazon SageMaker resource.
//
// To list a resource's tags, use the ListTags API.
//
//    // Example sending a request using the DeleteTagsRequest method.
//    req := client.DeleteTagsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteTags
func (c *SageMaker) DeleteTagsRequest(input *DeleteTagsInput) DeleteTagsRequest {
	op := &aws.Operation{
		Name:       opDeleteTags,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteTagsInput{}
	}

	output := &DeleteTagsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteTagsRequest{Request: req, Input: input, Copy: c.DeleteTagsRequest}
}

const opDescribeEndpoint = "DescribeEndpoint"

// DescribeEndpointRequest is a API request type for the DescribeEndpoint API operation.
type DescribeEndpointRequest struct {
	*aws.Request
	Input *DescribeEndpointInput
	Copy  func(*DescribeEndpointInput) DescribeEndpointRequest
}

// Send marshals and sends the DescribeEndpoint API request.
func (r DescribeEndpointRequest) Send() (*DescribeEndpointOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeEndpointOutput), nil
}

// DescribeEndpointRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Returns the description of an endpoint.
//
//    // Example sending a request using the DescribeEndpointRequest method.
//    req := client.DescribeEndpointRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeEndpoint
func (c *SageMaker) DescribeEndpointRequest(input *DescribeEndpointInput) DescribeEndpointRequest {
	op := &aws.Operation{
		Name:       opDescribeEndpoint,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeEndpointInput{}
	}

	output := &DescribeEndpointOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeEndpointRequest{Request: req, Input: input, Copy: c.DescribeEndpointRequest}
}

const opDescribeEndpointConfig = "DescribeEndpointConfig"

// DescribeEndpointConfigRequest is a API request type for the DescribeEndpointConfig API operation.
type DescribeEndpointConfigRequest struct {
	*aws.Request
	Input *DescribeEndpointConfigInput
	Copy  func(*DescribeEndpointConfigInput) DescribeEndpointConfigRequest
}

// Send marshals and sends the DescribeEndpointConfig API request.
func (r DescribeEndpointConfigRequest) Send() (*DescribeEndpointConfigOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeEndpointConfigOutput), nil
}

// DescribeEndpointConfigRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Returns the description of an endpoint configuration created using the CreateEndpointConfig
// API.
//
//    // Example sending a request using the DescribeEndpointConfigRequest method.
//    req := client.DescribeEndpointConfigRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeEndpointConfig
func (c *SageMaker) DescribeEndpointConfigRequest(input *DescribeEndpointConfigInput) DescribeEndpointConfigRequest {
	op := &aws.Operation{
		Name:       opDescribeEndpointConfig,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeEndpointConfigInput{}
	}

	output := &DescribeEndpointConfigOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeEndpointConfigRequest{Request: req, Input: input, Copy: c.DescribeEndpointConfigRequest}
}

const opDescribeModel = "DescribeModel"

// DescribeModelRequest is a API request type for the DescribeModel API operation.
type DescribeModelRequest struct {
	*aws.Request
	Input *DescribeModelInput
	Copy  func(*DescribeModelInput) DescribeModelRequest
}

// Send marshals and sends the DescribeModel API request.
func (r DescribeModelRequest) Send() (*DescribeModelOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeModelOutput), nil
}

// DescribeModelRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Describes a model that you created using the CreateModel API.
//
//    // Example sending a request using the DescribeModelRequest method.
//    req := client.DescribeModelRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeModel
func (c *SageMaker) DescribeModelRequest(input *DescribeModelInput) DescribeModelRequest {
	op := &aws.Operation{
		Name:       opDescribeModel,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeModelInput{}
	}

	output := &DescribeModelOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeModelRequest{Request: req, Input: input, Copy: c.DescribeModelRequest}
}

const opDescribeNotebookInstance = "DescribeNotebookInstance"

// DescribeNotebookInstanceRequest is a API request type for the DescribeNotebookInstance API operation.
type DescribeNotebookInstanceRequest struct {
	*aws.Request
	Input *DescribeNotebookInstanceInput
	Copy  func(*DescribeNotebookInstanceInput) DescribeNotebookInstanceRequest
}

// Send marshals and sends the DescribeNotebookInstance API request.
func (r DescribeNotebookInstanceRequest) Send() (*DescribeNotebookInstanceOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeNotebookInstanceOutput), nil
}

// DescribeNotebookInstanceRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Returns information about a notebook instance.
//
//    // Example sending a request using the DescribeNotebookInstanceRequest method.
//    req := client.DescribeNotebookInstanceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeNotebookInstance
func (c *SageMaker) DescribeNotebookInstanceRequest(input *DescribeNotebookInstanceInput) DescribeNotebookInstanceRequest {
	op := &aws.Operation{
		Name:       opDescribeNotebookInstance,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeNotebookInstanceInput{}
	}

	output := &DescribeNotebookInstanceOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeNotebookInstanceRequest{Request: req, Input: input, Copy: c.DescribeNotebookInstanceRequest}
}

const opDescribeNotebookInstanceLifecycleConfig = "DescribeNotebookInstanceLifecycleConfig"

// DescribeNotebookInstanceLifecycleConfigRequest is a API request type for the DescribeNotebookInstanceLifecycleConfig API operation.
type DescribeNotebookInstanceLifecycleConfigRequest struct {
	*aws.Request
	Input *DescribeNotebookInstanceLifecycleConfigInput
	Copy  func(*DescribeNotebookInstanceLifecycleConfigInput) DescribeNotebookInstanceLifecycleConfigRequest
}

// Send marshals and sends the DescribeNotebookInstanceLifecycleConfig API request.
func (r DescribeNotebookInstanceLifecycleConfigRequest) Send() (*DescribeNotebookInstanceLifecycleConfigOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeNotebookInstanceLifecycleConfigOutput), nil
}

// DescribeNotebookInstanceLifecycleConfigRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Returns a description of a notebook instance lifecycle configuration.
//
// For information about notebook instance lifestyle configurations, see notebook-lifecycle-config.
//
//    // Example sending a request using the DescribeNotebookInstanceLifecycleConfigRequest method.
//    req := client.DescribeNotebookInstanceLifecycleConfigRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeNotebookInstanceLifecycleConfig
func (c *SageMaker) DescribeNotebookInstanceLifecycleConfigRequest(input *DescribeNotebookInstanceLifecycleConfigInput) DescribeNotebookInstanceLifecycleConfigRequest {
	op := &aws.Operation{
		Name:       opDescribeNotebookInstanceLifecycleConfig,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeNotebookInstanceLifecycleConfigInput{}
	}

	output := &DescribeNotebookInstanceLifecycleConfigOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeNotebookInstanceLifecycleConfigRequest{Request: req, Input: input, Copy: c.DescribeNotebookInstanceLifecycleConfigRequest}
}

const opDescribeTrainingJob = "DescribeTrainingJob"

// DescribeTrainingJobRequest is a API request type for the DescribeTrainingJob API operation.
type DescribeTrainingJobRequest struct {
	*aws.Request
	Input *DescribeTrainingJobInput
	Copy  func(*DescribeTrainingJobInput) DescribeTrainingJobRequest
}

// Send marshals and sends the DescribeTrainingJob API request.
func (r DescribeTrainingJobRequest) Send() (*DescribeTrainingJobOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeTrainingJobOutput), nil
}

// DescribeTrainingJobRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Returns information about a training job.
//
//    // Example sending a request using the DescribeTrainingJobRequest method.
//    req := client.DescribeTrainingJobRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeTrainingJob
func (c *SageMaker) DescribeTrainingJobRequest(input *DescribeTrainingJobInput) DescribeTrainingJobRequest {
	op := &aws.Operation{
		Name:       opDescribeTrainingJob,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeTrainingJobInput{}
	}

	output := &DescribeTrainingJobOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeTrainingJobRequest{Request: req, Input: input, Copy: c.DescribeTrainingJobRequest}
}

const opListEndpointConfigs = "ListEndpointConfigs"

// ListEndpointConfigsRequest is a API request type for the ListEndpointConfigs API operation.
type ListEndpointConfigsRequest struct {
	*aws.Request
	Input *ListEndpointConfigsInput
	Copy  func(*ListEndpointConfigsInput) ListEndpointConfigsRequest
}

// Send marshals and sends the ListEndpointConfigs API request.
func (r ListEndpointConfigsRequest) Send() (*ListEndpointConfigsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListEndpointConfigsOutput), nil
}

// ListEndpointConfigsRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Lists endpoint configurations.
//
//    // Example sending a request using the ListEndpointConfigsRequest method.
//    req := client.ListEndpointConfigsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListEndpointConfigs
func (c *SageMaker) ListEndpointConfigsRequest(input *ListEndpointConfigsInput) ListEndpointConfigsRequest {
	op := &aws.Operation{
		Name:       opListEndpointConfigs,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListEndpointConfigsInput{}
	}

	output := &ListEndpointConfigsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListEndpointConfigsRequest{Request: req, Input: input, Copy: c.ListEndpointConfigsRequest}
}

// Paginate pages iterates over the pages of a ListEndpointConfigsRequest operation,
// calling the Next method for each page. Using the paginators Next
// method will depict whether or not there are more pages.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListEndpointConfigs operation.
//		req := client.ListEndpointConfigsRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *ListEndpointConfigsRequest) Paginate(opts ...aws.Option) ListEndpointConfigsPager {
	return ListEndpointConfigsPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *ListEndpointConfigsInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

				req := p.Copy(inCpy)
				req.ApplyOptions(opts...)

				return req.Request, nil
			},
		},
	}
}

// ListEndpointConfigsPager is used to paginate the request. This can be done by
// calling Next and CurrentPage.
type ListEndpointConfigsPager struct {
	aws.Pager
}

func (p *ListEndpointConfigsPager) CurrentPage() *ListEndpointConfigsOutput {
	return p.Pager.CurrentPage().(*ListEndpointConfigsOutput)
}

const opListEndpoints = "ListEndpoints"

// ListEndpointsRequest is a API request type for the ListEndpoints API operation.
type ListEndpointsRequest struct {
	*aws.Request
	Input *ListEndpointsInput
	Copy  func(*ListEndpointsInput) ListEndpointsRequest
}

// Send marshals and sends the ListEndpoints API request.
func (r ListEndpointsRequest) Send() (*ListEndpointsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListEndpointsOutput), nil
}

// ListEndpointsRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Lists endpoints.
//
//    // Example sending a request using the ListEndpointsRequest method.
//    req := client.ListEndpointsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListEndpoints
func (c *SageMaker) ListEndpointsRequest(input *ListEndpointsInput) ListEndpointsRequest {
	op := &aws.Operation{
		Name:       opListEndpoints,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListEndpointsInput{}
	}

	output := &ListEndpointsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListEndpointsRequest{Request: req, Input: input, Copy: c.ListEndpointsRequest}
}

// Paginate pages iterates over the pages of a ListEndpointsRequest operation,
// calling the Next method for each page. Using the paginators Next
// method will depict whether or not there are more pages.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListEndpoints operation.
//		req := client.ListEndpointsRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *ListEndpointsRequest) Paginate(opts ...aws.Option) ListEndpointsPager {
	return ListEndpointsPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *ListEndpointsInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

				req := p.Copy(inCpy)
				req.ApplyOptions(opts...)

				return req.Request, nil
			},
		},
	}
}

// ListEndpointsPager is used to paginate the request. This can be done by
// calling Next and CurrentPage.
type ListEndpointsPager struct {
	aws.Pager
}

func (p *ListEndpointsPager) CurrentPage() *ListEndpointsOutput {
	return p.Pager.CurrentPage().(*ListEndpointsOutput)
}

const opListModels = "ListModels"

// ListModelsRequest is a API request type for the ListModels API operation.
type ListModelsRequest struct {
	*aws.Request
	Input *ListModelsInput
	Copy  func(*ListModelsInput) ListModelsRequest
}

// Send marshals and sends the ListModels API request.
func (r ListModelsRequest) Send() (*ListModelsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListModelsOutput), nil
}

// ListModelsRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Lists models created with the CreateModel (http://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateModel.html)
// API.
//
//    // Example sending a request using the ListModelsRequest method.
//    req := client.ListModelsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListModels
func (c *SageMaker) ListModelsRequest(input *ListModelsInput) ListModelsRequest {
	op := &aws.Operation{
		Name:       opListModels,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListModelsInput{}
	}

	output := &ListModelsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListModelsRequest{Request: req, Input: input, Copy: c.ListModelsRequest}
}

// Paginate pages iterates over the pages of a ListModelsRequest operation,
// calling the Next method for each page. Using the paginators Next
// method will depict whether or not there are more pages.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListModels operation.
//		req := client.ListModelsRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *ListModelsRequest) Paginate(opts ...aws.Option) ListModelsPager {
	return ListModelsPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *ListModelsInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

				req := p.Copy(inCpy)
				req.ApplyOptions(opts...)

				return req.Request, nil
			},
		},
	}
}

// ListModelsPager is used to paginate the request. This can be done by
// calling Next and CurrentPage.
type ListModelsPager struct {
	aws.Pager
}

func (p *ListModelsPager) CurrentPage() *ListModelsOutput {
	return p.Pager.CurrentPage().(*ListModelsOutput)
}

const opListNotebookInstanceLifecycleConfigs = "ListNotebookInstanceLifecycleConfigs"

// ListNotebookInstanceLifecycleConfigsRequest is a API request type for the ListNotebookInstanceLifecycleConfigs API operation.
type ListNotebookInstanceLifecycleConfigsRequest struct {
	*aws.Request
	Input *ListNotebookInstanceLifecycleConfigsInput
	Copy  func(*ListNotebookInstanceLifecycleConfigsInput) ListNotebookInstanceLifecycleConfigsRequest
}

// Send marshals and sends the ListNotebookInstanceLifecycleConfigs API request.
func (r ListNotebookInstanceLifecycleConfigsRequest) Send() (*ListNotebookInstanceLifecycleConfigsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListNotebookInstanceLifecycleConfigsOutput), nil
}

// ListNotebookInstanceLifecycleConfigsRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Lists notebook instance lifestyle configurations created with the API.
//
//    // Example sending a request using the ListNotebookInstanceLifecycleConfigsRequest method.
//    req := client.ListNotebookInstanceLifecycleConfigsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListNotebookInstanceLifecycleConfigs
func (c *SageMaker) ListNotebookInstanceLifecycleConfigsRequest(input *ListNotebookInstanceLifecycleConfigsInput) ListNotebookInstanceLifecycleConfigsRequest {
	op := &aws.Operation{
		Name:       opListNotebookInstanceLifecycleConfigs,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListNotebookInstanceLifecycleConfigsInput{}
	}

	output := &ListNotebookInstanceLifecycleConfigsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListNotebookInstanceLifecycleConfigsRequest{Request: req, Input: input, Copy: c.ListNotebookInstanceLifecycleConfigsRequest}
}

// Paginate pages iterates over the pages of a ListNotebookInstanceLifecycleConfigsRequest operation,
// calling the Next method for each page. Using the paginators Next
// method will depict whether or not there are more pages.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListNotebookInstanceLifecycleConfigs operation.
//		req := client.ListNotebookInstanceLifecycleConfigsRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *ListNotebookInstanceLifecycleConfigsRequest) Paginate(opts ...aws.Option) ListNotebookInstanceLifecycleConfigsPager {
	return ListNotebookInstanceLifecycleConfigsPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *ListNotebookInstanceLifecycleConfigsInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

				req := p.Copy(inCpy)
				req.ApplyOptions(opts...)

				return req.Request, nil
			},
		},
	}
}

// ListNotebookInstanceLifecycleConfigsPager is used to paginate the request. This can be done by
// calling Next and CurrentPage.
type ListNotebookInstanceLifecycleConfigsPager struct {
	aws.Pager
}

func (p *ListNotebookInstanceLifecycleConfigsPager) CurrentPage() *ListNotebookInstanceLifecycleConfigsOutput {
	return p.Pager.CurrentPage().(*ListNotebookInstanceLifecycleConfigsOutput)
}

const opListNotebookInstances = "ListNotebookInstances"

// ListNotebookInstancesRequest is a API request type for the ListNotebookInstances API operation.
type ListNotebookInstancesRequest struct {
	*aws.Request
	Input *ListNotebookInstancesInput
	Copy  func(*ListNotebookInstancesInput) ListNotebookInstancesRequest
}

// Send marshals and sends the ListNotebookInstances API request.
func (r ListNotebookInstancesRequest) Send() (*ListNotebookInstancesOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListNotebookInstancesOutput), nil
}

// ListNotebookInstancesRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Returns a list of the Amazon SageMaker notebook instances in the requester's
// account in an AWS Region.
//
//    // Example sending a request using the ListNotebookInstancesRequest method.
//    req := client.ListNotebookInstancesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListNotebookInstances
func (c *SageMaker) ListNotebookInstancesRequest(input *ListNotebookInstancesInput) ListNotebookInstancesRequest {
	op := &aws.Operation{
		Name:       opListNotebookInstances,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListNotebookInstancesInput{}
	}

	output := &ListNotebookInstancesOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListNotebookInstancesRequest{Request: req, Input: input, Copy: c.ListNotebookInstancesRequest}
}

// Paginate pages iterates over the pages of a ListNotebookInstancesRequest operation,
// calling the Next method for each page. Using the paginators Next
// method will depict whether or not there are more pages.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListNotebookInstances operation.
//		req := client.ListNotebookInstancesRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *ListNotebookInstancesRequest) Paginate(opts ...aws.Option) ListNotebookInstancesPager {
	return ListNotebookInstancesPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *ListNotebookInstancesInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

				req := p.Copy(inCpy)
				req.ApplyOptions(opts...)

				return req.Request, nil
			},
		},
	}
}

// ListNotebookInstancesPager is used to paginate the request. This can be done by
// calling Next and CurrentPage.
type ListNotebookInstancesPager struct {
	aws.Pager
}

func (p *ListNotebookInstancesPager) CurrentPage() *ListNotebookInstancesOutput {
	return p.Pager.CurrentPage().(*ListNotebookInstancesOutput)
}

const opListTags = "ListTags"

// ListTagsRequest is a API request type for the ListTags API operation.
type ListTagsRequest struct {
	*aws.Request
	Input *ListTagsInput
	Copy  func(*ListTagsInput) ListTagsRequest
}

// Send marshals and sends the ListTags API request.
func (r ListTagsRequest) Send() (*ListTagsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListTagsOutput), nil
}

// ListTagsRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Returns the tags for the specified Amazon SageMaker resource.
//
//    // Example sending a request using the ListTagsRequest method.
//    req := client.ListTagsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListTags
func (c *SageMaker) ListTagsRequest(input *ListTagsInput) ListTagsRequest {
	op := &aws.Operation{
		Name:       opListTags,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListTagsInput{}
	}

	output := &ListTagsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListTagsRequest{Request: req, Input: input, Copy: c.ListTagsRequest}
}

// Paginate pages iterates over the pages of a ListTagsRequest operation,
// calling the Next method for each page. Using the paginators Next
// method will depict whether or not there are more pages.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListTags operation.
//		req := client.ListTagsRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *ListTagsRequest) Paginate(opts ...aws.Option) ListTagsPager {
	return ListTagsPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *ListTagsInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

				req := p.Copy(inCpy)
				req.ApplyOptions(opts...)

				return req.Request, nil
			},
		},
	}
}

// ListTagsPager is used to paginate the request. This can be done by
// calling Next and CurrentPage.
type ListTagsPager struct {
	aws.Pager
}

func (p *ListTagsPager) CurrentPage() *ListTagsOutput {
	return p.Pager.CurrentPage().(*ListTagsOutput)
}

const opListTrainingJobs = "ListTrainingJobs"

// ListTrainingJobsRequest is a API request type for the ListTrainingJobs API operation.
type ListTrainingJobsRequest struct {
	*aws.Request
	Input *ListTrainingJobsInput
	Copy  func(*ListTrainingJobsInput) ListTrainingJobsRequest
}

// Send marshals and sends the ListTrainingJobs API request.
func (r ListTrainingJobsRequest) Send() (*ListTrainingJobsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListTrainingJobsOutput), nil
}

// ListTrainingJobsRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Lists training jobs.
//
//    // Example sending a request using the ListTrainingJobsRequest method.
//    req := client.ListTrainingJobsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListTrainingJobs
func (c *SageMaker) ListTrainingJobsRequest(input *ListTrainingJobsInput) ListTrainingJobsRequest {
	op := &aws.Operation{
		Name:       opListTrainingJobs,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListTrainingJobsInput{}
	}

	output := &ListTrainingJobsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListTrainingJobsRequest{Request: req, Input: input, Copy: c.ListTrainingJobsRequest}
}

// Paginate pages iterates over the pages of a ListTrainingJobsRequest operation,
// calling the Next method for each page. Using the paginators Next
// method will depict whether or not there are more pages.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListTrainingJobs operation.
//		req := client.ListTrainingJobsRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *ListTrainingJobsRequest) Paginate(opts ...aws.Option) ListTrainingJobsPager {
	return ListTrainingJobsPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *ListTrainingJobsInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

				req := p.Copy(inCpy)
				req.ApplyOptions(opts...)

				return req.Request, nil
			},
		},
	}
}

// ListTrainingJobsPager is used to paginate the request. This can be done by
// calling Next and CurrentPage.
type ListTrainingJobsPager struct {
	aws.Pager
}

func (p *ListTrainingJobsPager) CurrentPage() *ListTrainingJobsOutput {
	return p.Pager.CurrentPage().(*ListTrainingJobsOutput)
}

const opStartNotebookInstance = "StartNotebookInstance"

// StartNotebookInstanceRequest is a API request type for the StartNotebookInstance API operation.
type StartNotebookInstanceRequest struct {
	*aws.Request
	Input *StartNotebookInstanceInput
	Copy  func(*StartNotebookInstanceInput) StartNotebookInstanceRequest
}

// Send marshals and sends the StartNotebookInstance API request.
func (r StartNotebookInstanceRequest) Send() (*StartNotebookInstanceOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*StartNotebookInstanceOutput), nil
}

// StartNotebookInstanceRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// 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 InService. A notebook
// instance's status must be InService before you can connect to your Jupyter
// notebook.
//
//    // Example sending a request using the StartNotebookInstanceRequest method.
//    req := client.StartNotebookInstanceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/StartNotebookInstance
func (c *SageMaker) StartNotebookInstanceRequest(input *StartNotebookInstanceInput) StartNotebookInstanceRequest {
	op := &aws.Operation{
		Name:       opStartNotebookInstance,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &StartNotebookInstanceInput{}
	}

	output := &StartNotebookInstanceOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}

	return StartNotebookInstanceRequest{Request: req, Input: input, Copy: c.StartNotebookInstanceRequest}
}

const opStopNotebookInstance = "StopNotebookInstance"

// StopNotebookInstanceRequest is a API request type for the StopNotebookInstance API operation.
type StopNotebookInstanceRequest struct {
	*aws.Request
	Input *StopNotebookInstanceInput
	Copy  func(*StopNotebookInstanceInput) StopNotebookInstanceRequest
}

// Send marshals and sends the StopNotebookInstance API request.
func (r StopNotebookInstanceRequest) Send() (*StopNotebookInstanceOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*StopNotebookInstanceOutput), nil
}

// StopNotebookInstanceRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// 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.
//
// To access data on the ML storage volume for a notebook instance that has
// been terminated, call the StartNotebookInstance API. StartNotebookInstance
// launches another ML compute instance, configures it, and attaches the preserved
// ML storage volume so you can continue your work.
//
//    // Example sending a request using the StopNotebookInstanceRequest method.
//    req := client.StopNotebookInstanceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/StopNotebookInstance
func (c *SageMaker) StopNotebookInstanceRequest(input *StopNotebookInstanceInput) StopNotebookInstanceRequest {
	op := &aws.Operation{
		Name:       opStopNotebookInstance,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &StopNotebookInstanceInput{}
	}

	output := &StopNotebookInstanceOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}

	return StopNotebookInstanceRequest{Request: req, Input: input, Copy: c.StopNotebookInstanceRequest}
}

const opStopTrainingJob = "StopTrainingJob"

// StopTrainingJobRequest is a API request type for the StopTrainingJob API operation.
type StopTrainingJobRequest struct {
	*aws.Request
	Input *StopTrainingJobInput
	Copy  func(*StopTrainingJobInput) StopTrainingJobRequest
}

// Send marshals and sends the StopTrainingJob API request.
func (r StopTrainingJobRequest) Send() (*StopTrainingJobOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*StopTrainingJobOutput), nil
}

// StopTrainingJobRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Stops a training job. To stop a job, Amazon SageMaker sends the algorithm
// the SIGTERM 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.
//
// Training algorithms provided by Amazon SageMaker save the intermediate results
// of a model training job. This intermediate data is a valid model artifact.
// You can use the model artifacts that are saved when Amazon SageMaker stops
// a training job to create a model.
//
// When it receives a StopTrainingJob request, Amazon SageMaker changes the
// status of the job to Stopping. After Amazon SageMaker stops the job, it sets
// the status to Stopped.
//
//    // Example sending a request using the StopTrainingJobRequest method.
//    req := client.StopTrainingJobRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/StopTrainingJob
func (c *SageMaker) StopTrainingJobRequest(input *StopTrainingJobInput) StopTrainingJobRequest {
	op := &aws.Operation{
		Name:       opStopTrainingJob,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &StopTrainingJobInput{}
	}

	output := &StopTrainingJobOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}

	return StopTrainingJobRequest{Request: req, Input: input, Copy: c.StopTrainingJobRequest}
}

const opUpdateEndpoint = "UpdateEndpoint"

// UpdateEndpointRequest is a API request type for the UpdateEndpoint API operation.
type UpdateEndpointRequest struct {
	*aws.Request
	Input *UpdateEndpointInput
	Copy  func(*UpdateEndpointInput) UpdateEndpointRequest
}

// Send marshals and sends the UpdateEndpoint API request.
func (r UpdateEndpointRequest) Send() (*UpdateEndpointOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateEndpointOutput), nil
}

// UpdateEndpointRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Deploys the new EndpointConfig specified in the request, switches to using
// newly created endpoint, and then deletes resources provisioned for the endpoint
// using the previous EndpointConfig (there is no availability loss).
//
// When Amazon SageMaker receives the request, it sets the endpoint status to
// Updating. After updating the endpoint, it sets the status to InService. To
// check the status of an endpoint, use the DescribeEndpoint (http://docs.aws.amazon.com/sagemaker/latest/dg/API_DescribeEndpoint.html)
// API.
//
//    // Example sending a request using the UpdateEndpointRequest method.
//    req := client.UpdateEndpointRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/UpdateEndpoint
func (c *SageMaker) UpdateEndpointRequest(input *UpdateEndpointInput) UpdateEndpointRequest {
	op := &aws.Operation{
		Name:       opUpdateEndpoint,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateEndpointInput{}
	}

	output := &UpdateEndpointOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateEndpointRequest{Request: req, Input: input, Copy: c.UpdateEndpointRequest}
}

const opUpdateEndpointWeightsAndCapacities = "UpdateEndpointWeightsAndCapacities"

// UpdateEndpointWeightsAndCapacitiesRequest is a API request type for the UpdateEndpointWeightsAndCapacities API operation.
type UpdateEndpointWeightsAndCapacitiesRequest struct {
	*aws.Request
	Input *UpdateEndpointWeightsAndCapacitiesInput
	Copy  func(*UpdateEndpointWeightsAndCapacitiesInput) UpdateEndpointWeightsAndCapacitiesRequest
}

// Send marshals and sends the UpdateEndpointWeightsAndCapacities API request.
func (r UpdateEndpointWeightsAndCapacitiesRequest) Send() (*UpdateEndpointWeightsAndCapacitiesOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateEndpointWeightsAndCapacitiesOutput), nil
}

// UpdateEndpointWeightsAndCapacitiesRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// 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
// Updating. After updating the endpoint, it sets the status to InService. To
// check the status of an endpoint, use the DescribeEndpoint (http://docs.aws.amazon.com/sagemaker/latest/dg/API_DescribeEndpoint.html)
// API.
//
//    // Example sending a request using the UpdateEndpointWeightsAndCapacitiesRequest method.
//    req := client.UpdateEndpointWeightsAndCapacitiesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/UpdateEndpointWeightsAndCapacities
func (c *SageMaker) UpdateEndpointWeightsAndCapacitiesRequest(input *UpdateEndpointWeightsAndCapacitiesInput) UpdateEndpointWeightsAndCapacitiesRequest {
	op := &aws.Operation{
		Name:       opUpdateEndpointWeightsAndCapacities,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateEndpointWeightsAndCapacitiesInput{}
	}

	output := &UpdateEndpointWeightsAndCapacitiesOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateEndpointWeightsAndCapacitiesRequest{Request: req, Input: input, Copy: c.UpdateEndpointWeightsAndCapacitiesRequest}
}

const opUpdateNotebookInstance = "UpdateNotebookInstance"

// UpdateNotebookInstanceRequest is a API request type for the UpdateNotebookInstance API operation.
type UpdateNotebookInstanceRequest struct {
	*aws.Request
	Input *UpdateNotebookInstanceInput
	Copy  func(*UpdateNotebookInstanceInput) UpdateNotebookInstanceRequest
}

// Send marshals and sends the UpdateNotebookInstance API request.
func (r UpdateNotebookInstanceRequest) Send() (*UpdateNotebookInstanceOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateNotebookInstanceOutput), nil
}

// UpdateNotebookInstanceRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// 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. You can also update the VPC security
// groups.
//
//    // Example sending a request using the UpdateNotebookInstanceRequest method.
//    req := client.UpdateNotebookInstanceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/UpdateNotebookInstance
func (c *SageMaker) UpdateNotebookInstanceRequest(input *UpdateNotebookInstanceInput) UpdateNotebookInstanceRequest {
	op := &aws.Operation{
		Name:       opUpdateNotebookInstance,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateNotebookInstanceInput{}
	}

	output := &UpdateNotebookInstanceOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateNotebookInstanceRequest{Request: req, Input: input, Copy: c.UpdateNotebookInstanceRequest}
}

const opUpdateNotebookInstanceLifecycleConfig = "UpdateNotebookInstanceLifecycleConfig"

// UpdateNotebookInstanceLifecycleConfigRequest is a API request type for the UpdateNotebookInstanceLifecycleConfig API operation.
type UpdateNotebookInstanceLifecycleConfigRequest struct {
	*aws.Request
	Input *UpdateNotebookInstanceLifecycleConfigInput
	Copy  func(*UpdateNotebookInstanceLifecycleConfigInput) UpdateNotebookInstanceLifecycleConfigRequest
}

// Send marshals and sends the UpdateNotebookInstanceLifecycleConfig API request.
func (r UpdateNotebookInstanceLifecycleConfigRequest) Send() (*UpdateNotebookInstanceLifecycleConfigOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateNotebookInstanceLifecycleConfigOutput), nil
}

// UpdateNotebookInstanceLifecycleConfigRequest returns a request value for making API operation for
// Amazon SageMaker Service.
//
// Updates a notebook instance lifecycle configuration created with the API.
//
//    // Example sending a request using the UpdateNotebookInstanceLifecycleConfigRequest method.
//    req := client.UpdateNotebookInstanceLifecycleConfigRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/UpdateNotebookInstanceLifecycleConfig
func (c *SageMaker) UpdateNotebookInstanceLifecycleConfigRequest(input *UpdateNotebookInstanceLifecycleConfigInput) UpdateNotebookInstanceLifecycleConfigRequest {
	op := &aws.Operation{
		Name:       opUpdateNotebookInstanceLifecycleConfig,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateNotebookInstanceLifecycleConfigInput{}
	}

	output := &UpdateNotebookInstanceLifecycleConfigOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateNotebookInstanceLifecycleConfigRequest{Request: req, Input: input, Copy: c.UpdateNotebookInstanceLifecycleConfigRequest}
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/AddTagsInput
type AddTagsInput struct {
	_ struct{} `type:"structure"`

	// The Amazon Resource Name (ARN) of the resource that you want to tag.
	//
	// ResourceArn is a required field
	ResourceArn *string `type:"string" required:"true"`

	// An array of Tag objects. Each tag is a key-value pair. Only the key parameter
	// is required. If you don't specify a value, Amazon SageMaker sets the value
	// to an empty string.
	//
	// Tags is a required field
	Tags []Tag `type:"list" required:"true"`
}

// String returns the string representation
func (s AddTagsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AddTagsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *AddTagsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "AddTagsInput"}

	if s.ResourceArn == nil {
		invalidParams.Add(aws.NewErrParamRequired("ResourceArn"))
	}

	if s.Tags == nil {
		invalidParams.Add(aws.NewErrParamRequired("Tags"))
	}
	if s.Tags != nil {
		for i, v := range s.Tags {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/AddTagsOutput
type AddTagsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// A list of tags associated with the Amazon SageMaker resource.
	Tags []Tag `type:"list"`
}

// String returns the string representation
func (s AddTagsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AddTagsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s AddTagsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Specifies the training algorithm to use in a CreateTrainingJob (http://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateTrainingJob.html)
// request.
//
// For more information about algorithms provided by Amazon SageMaker, see Algorithms
// (http://docs.aws.amazon.com/sagemaker/latest/dg/algos.html). For information
// about using your own algorithms, see your-algorithms.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/AlgorithmSpecification
type AlgorithmSpecification struct {
	_ struct{} `type:"structure"`

	// The registry path of the Docker image that contains the training algorithm.
	// For information about docker registry paths for built-in algorithms, see
	// sagemaker-algo-docker-registry-paths.
	//
	// TrainingImage is a required field
	TrainingImage *string `type:"string" required:"true"`

	// The input mode that the algorithm supports. For the input modes that Amazon
	// SageMaker algorithms support, see Algorithms (http://docs.aws.amazon.com/sagemaker/latest/dg/algos.html).
	// If an algorithm supports the File 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 Pipe input mode, Amazon SageMaker streams data directly from S3 to the
	// container.
	//
	// 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.
	//
	// 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.
	//
	// TrainingInputMode is a required field
	TrainingInputMode TrainingInputMode `type:"string" required:"true" enum:"true"`
}

// String returns the string representation
func (s AlgorithmSpecification) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AlgorithmSpecification) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *AlgorithmSpecification) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "AlgorithmSpecification"}

	if s.TrainingImage == nil {
		invalidParams.Add(aws.NewErrParamRequired("TrainingImage"))
	}
	if len(s.TrainingInputMode) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("TrainingInputMode"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// A channel is a named input source that training algorithms can consume.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/Channel
type Channel struct {
	_ struct{} `type:"structure"`

	// The name of the channel.
	//
	// ChannelName is a required field
	ChannelName *string `min:"1" type:"string" required:"true"`

	// If training data is compressed, the compression type. The default value is
	// None. CompressionType is used only in PIPE input mode. In FILE mode, leave
	// this field unset or set it to None.
	CompressionType CompressionType `type:"string" enum:"true"`

	// The MIME type of the data.
	ContentType *string `type:"string"`

	// The location of the channel data.
	//
	// DataSource is a required field
	DataSource *DataSource `type:"structure" required:"true"`

	// Specify RecordIO as the value when input data is in raw format but the training
	// algorithm requires the RecordIO format, in which caseAmazon SageMaker wraps
	// each individual S3 object in a RecordIO record. If the input data is already
	// in RecordIO format, you don't need to set this attribute. For more information,
	// see Create a Dataset Using RecordIO (https://mxnet.incubator.apache.org/how_to/recordio.html?highlight=im2rec)
	RecordWrapperType RecordWrapper `type:"string" enum:"true"`
}

// String returns the string representation
func (s Channel) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s Channel) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *Channel) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "Channel"}

	if s.ChannelName == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChannelName"))
	}
	if s.ChannelName != nil && len(*s.ChannelName) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChannelName", 1))
	}

	if s.DataSource == nil {
		invalidParams.Add(aws.NewErrParamRequired("DataSource"))
	}
	if s.DataSource != nil {
		if err := s.DataSource.Validate(); err != nil {
			invalidParams.AddNested("DataSource", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Describes the container, as part of model definition.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ContainerDefinition
type ContainerDefinition struct {
	_ struct{} `type:"structure"`

	// The DNS host name for the container after Amazon SageMaker deploys it.
	ContainerHostname *string `type:"string"`

	// The environment variables to set in the Docker container. Each key and value
	// in the Environment string to string map can have length of up to 1024. We
	// support up to 16 entries in the map.
	Environment map[string]string `type:"map"`

	// The Amazon EC2 Container Registry (Amazon ECR) path where inference code
	// is stored. If you are using your own custom algorithm instead of an algorithm
	// provided by Amazon SageMaker, the inference code must meet Amazon SageMaker
	// requirements. For more information, see Using Your Own Algorithms with Amazon
	// SageMaker (http://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms.html)
	//
	// Image is a required field
	Image *string `type:"string" required:"true"`

	// 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).
	ModelDataUrl *string `type:"string"`
}

// String returns the string representation
func (s ContainerDefinition) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ContainerDefinition) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ContainerDefinition) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ContainerDefinition"}

	if s.Image == nil {
		invalidParams.Add(aws.NewErrParamRequired("Image"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateEndpointConfigInput
type CreateEndpointConfigInput struct {
	_ struct{} `type:"structure"`

	// The name of the endpoint configuration. You specify this name in a CreateEndpoint
	// (http://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateEndpoint.html)
	// request.
	//
	// EndpointConfigName is a required field
	EndpointConfigName *string `type:"string" required:"true"`

	// 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.
	KmsKeyId *string `type:"string"`

	// An array of ProductionVariant objects, one for each model that you want to
	// host at this endpoint.
	//
	// ProductionVariants is a required field
	ProductionVariants []ProductionVariant `min:"1" type:"list" required:"true"`

	// An array of key-value pairs. For more information, see Using Cost Allocation
	// Tags (http://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-what)
	// in the AWS Billing and Cost Management User Guide.
	Tags []Tag `type:"list"`
}

// String returns the string representation
func (s CreateEndpointConfigInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateEndpointConfigInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateEndpointConfigInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateEndpointConfigInput"}

	if s.EndpointConfigName == nil {
		invalidParams.Add(aws.NewErrParamRequired("EndpointConfigName"))
	}

	if s.ProductionVariants == nil {
		invalidParams.Add(aws.NewErrParamRequired("ProductionVariants"))
	}
	if s.ProductionVariants != nil && len(s.ProductionVariants) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ProductionVariants", 1))
	}
	if s.ProductionVariants != nil {
		for i, v := range s.ProductionVariants {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "ProductionVariants", i), err.(aws.ErrInvalidParams))
			}
		}
	}
	if s.Tags != nil {
		for i, v := range s.Tags {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateEndpointConfigOutput
type CreateEndpointConfigOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The Amazon Resource Name (ARN) of the endpoint configuration.
	//
	// EndpointConfigArn is a required field
	EndpointConfigArn *string `min:"20" type:"string" required:"true"`
}

// String returns the string representation
func (s CreateEndpointConfigOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateEndpointConfigOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateEndpointConfigOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateEndpointInput
type CreateEndpointInput struct {
	_ struct{} `type:"structure"`

	// The name of an endpoint configuration. For more information, see CreateEndpointConfig
	// (http://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateEndpointConfig.html).
	//
	// EndpointConfigName is a required field
	EndpointConfigName *string `type:"string" required:"true"`

	// The name of the endpoint. The name must be unique within an AWS Region in
	// your AWS account.
	//
	// EndpointName is a required field
	EndpointName *string `type:"string" required:"true"`

	// An array of key-value pairs. For more information, see Using Cost Allocation
	// Tags (http://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-what)in
	// the AWS Billing and Cost Management User Guide.
	Tags []Tag `type:"list"`
}

// String returns the string representation
func (s CreateEndpointInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateEndpointInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateEndpointInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateEndpointInput"}

	if s.EndpointConfigName == nil {
		invalidParams.Add(aws.NewErrParamRequired("EndpointConfigName"))
	}

	if s.EndpointName == nil {
		invalidParams.Add(aws.NewErrParamRequired("EndpointName"))
	}
	if s.Tags != nil {
		for i, v := range s.Tags {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateEndpointOutput
type CreateEndpointOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The Amazon Resource Name (ARN) of the endpoint.
	//
	// EndpointArn is a required field
	EndpointArn *string `min:"20" type:"string" required:"true"`
}

// String returns the string representation
func (s CreateEndpointOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateEndpointOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateEndpointOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateModelInput
type CreateModelInput struct {
	_ struct{} `type:"structure"`

	// 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. Deploying on ML compute instances is part of model hosting. For
	// more information, see Amazon SageMaker Roles (http://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html).
	//
	// ExecutionRoleArn is a required field
	ExecutionRoleArn *string `min:"20" type:"string" required:"true"`

	// The name of the new model.
	//
	// ModelName is a required field
	ModelName *string `type:"string" required:"true"`

	// 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 into production.
	//
	// PrimaryContainer is a required field
	PrimaryContainer *ContainerDefinition `type:"structure" required:"true"`

	// An array of key-value pairs. For more information, see Using Cost Allocation
	// Tags (http://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-what)
	// in the AWS Billing and Cost Management User Guide.
	Tags []Tag `type:"list"`

	// A object that specifies the VPC that you want your model to connect to. Control
	// access to and from your training container by configuring the VPC. For more
	// information, see host-vpc.
	VpcConfig *VpcConfig `type:"structure"`
}

// String returns the string representation
func (s CreateModelInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateModelInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateModelInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateModelInput"}

	if s.ExecutionRoleArn == nil {
		invalidParams.Add(aws.NewErrParamRequired("ExecutionRoleArn"))
	}
	if s.ExecutionRoleArn != nil && len(*s.ExecutionRoleArn) < 20 {
		invalidParams.Add(aws.NewErrParamMinLen("ExecutionRoleArn", 20))
	}

	if s.ModelName == nil {
		invalidParams.Add(aws.NewErrParamRequired("ModelName"))
	}

	if s.PrimaryContainer == nil {
		invalidParams.Add(aws.NewErrParamRequired("PrimaryContainer"))
	}
	if s.PrimaryContainer != nil {
		if err := s.PrimaryContainer.Validate(); err != nil {
			invalidParams.AddNested("PrimaryContainer", err.(aws.ErrInvalidParams))
		}
	}
	if s.Tags != nil {
		for i, v := range s.Tags {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(aws.ErrInvalidParams))
			}
		}
	}
	if s.VpcConfig != nil {
		if err := s.VpcConfig.Validate(); err != nil {
			invalidParams.AddNested("VpcConfig", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateModelOutput
type CreateModelOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ARN of the model created in Amazon SageMaker.
	//
	// ModelArn is a required field
	ModelArn *string `min:"20" type:"string" required:"true"`
}

// String returns the string representation
func (s CreateModelOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateModelOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateModelOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateNotebookInstanceInput
type CreateNotebookInstanceInput struct {
	_ struct{} `type:"structure"`

	// Sets whether Amazon SageMaker provides internet access to the notebook instance.
	// If you set this to Disabled 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.
	//
	// For more information, see appendix-notebook-and-internet-access. You can
	// set the value of this parameter to Disabled only if you set a value for the
	// SubnetId parameter.
	DirectInternetAccess DirectInternetAccess `type:"string" enum:"true"`

	// The type of ML compute instance to launch for the notebook instance.
	//
	// InstanceType is a required field
	InstanceType InstanceType `type:"string" required:"true" enum:"true"`

	// If you provide a AWS KMS key ID, Amazon SageMaker uses it to encrypt data
	// at rest on the ML storage volume that is attached to your notebook instance.
	KmsKeyId *string `type:"string"`

	// The name of a lifecycle configuration to associate with the notebook instance.
	// For information about lifestyle configurations, see notebook-lifecycle-config.
	LifecycleConfigName *string `type:"string"`

	// The name of the new notebook instance.
	//
	// NotebookInstanceName is a required field
	NotebookInstanceName *string `type:"string" required:"true"`

	// 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 Amazon SageMaker
	// Roles (http://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html).
	//
	// RoleArn is a required field
	RoleArn *string `min:"20" type:"string" required:"true"`

	// The VPC security group IDs, in the form sg-xxxxxxxx. The security groups
	// must be for the same VPC as specified in the subnet.
	SecurityGroupIds []string `type:"list"`

	// The ID of the subnet in a VPC to which you would like to have a connectivity
	// from your ML compute instance.
	SubnetId *string `type:"string"`

	// A list of tags to associate with the notebook instance. You can add tags
	// later by using the CreateTags API.
	Tags []Tag `type:"list"`
}

// String returns the string representation
func (s CreateNotebookInstanceInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateNotebookInstanceInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateNotebookInstanceInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateNotebookInstanceInput"}
	if len(s.InstanceType) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("InstanceType"))
	}

	if s.NotebookInstanceName == nil {
		invalidParams.Add(aws.NewErrParamRequired("NotebookInstanceName"))
	}

	if s.RoleArn == nil {
		invalidParams.Add(aws.NewErrParamRequired("RoleArn"))
	}
	if s.RoleArn != nil && len(*s.RoleArn) < 20 {
		invalidParams.Add(aws.NewErrParamMinLen("RoleArn", 20))
	}
	if s.Tags != nil {
		for i, v := range s.Tags {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateNotebookInstanceLifecycleConfigInput
type CreateNotebookInstanceLifecycleConfigInput struct {
	_ struct{} `type:"structure"`

	// The name of the lifecycle configuration.
	//
	// NotebookInstanceLifecycleConfigName is a required field
	NotebookInstanceLifecycleConfigName *string `type:"string" required:"true"`

	// A shell script that runs only once, when you create a notebook instance.
	OnCreate []NotebookInstanceLifecycleHook `type:"list"`

	// A shell script that runs every time you start a notebook instance, including
	// when you create the notebook instance.
	OnStart []NotebookInstanceLifecycleHook `type:"list"`
}

// String returns the string representation
func (s CreateNotebookInstanceLifecycleConfigInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateNotebookInstanceLifecycleConfigInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateNotebookInstanceLifecycleConfigInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateNotebookInstanceLifecycleConfigInput"}

	if s.NotebookInstanceLifecycleConfigName == nil {
		invalidParams.Add(aws.NewErrParamRequired("NotebookInstanceLifecycleConfigName"))
	}
	if s.OnCreate != nil {
		for i, v := range s.OnCreate {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "OnCreate", i), err.(aws.ErrInvalidParams))
			}
		}
	}
	if s.OnStart != nil {
		for i, v := range s.OnStart {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "OnStart", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateNotebookInstanceLifecycleConfigOutput
type CreateNotebookInstanceLifecycleConfigOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The Amazon Resource Name (ARN) of the lifecycle configuration.
	NotebookInstanceLifecycleConfigArn *string `type:"string"`
}

// String returns the string representation
func (s CreateNotebookInstanceLifecycleConfigOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateNotebookInstanceLifecycleConfigOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateNotebookInstanceLifecycleConfigOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateNotebookInstanceOutput
type CreateNotebookInstanceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The Amazon Resource Name (ARN) of the notebook instance.
	NotebookInstanceArn *string `type:"string"`
}

// String returns the string representation
func (s CreateNotebookInstanceOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateNotebookInstanceOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateNotebookInstanceOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreatePresignedNotebookInstanceUrlInput
type CreatePresignedNotebookInstanceUrlInput struct {
	_ struct{} `type:"structure"`

	// The name of the notebook instance.
	//
	// NotebookInstanceName is a required field
	NotebookInstanceName *string `type:"string" required:"true"`

	// The duration of the session, in seconds. The default is 12 hours.
	SessionExpirationDurationInSeconds *int64 `min:"1800" type:"integer"`
}

// String returns the string representation
func (s CreatePresignedNotebookInstanceUrlInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreatePresignedNotebookInstanceUrlInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreatePresignedNotebookInstanceUrlInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreatePresignedNotebookInstanceUrlInput"}

	if s.NotebookInstanceName == nil {
		invalidParams.Add(aws.NewErrParamRequired("NotebookInstanceName"))
	}
	if s.SessionExpirationDurationInSeconds != nil && *s.SessionExpirationDurationInSeconds < 1800 {
		invalidParams.Add(aws.NewErrParamMinValue("SessionExpirationDurationInSeconds", 1800))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreatePresignedNotebookInstanceUrlOutput
type CreatePresignedNotebookInstanceUrlOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// A JSON object that contains the URL string.
	AuthorizedUrl *string `type:"string"`
}

// String returns the string representation
func (s CreatePresignedNotebookInstanceUrlOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreatePresignedNotebookInstanceUrlOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreatePresignedNotebookInstanceUrlOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateTrainingJobRequest
type CreateTrainingJobInput struct {
	_ struct{} `type:"structure"`

	// 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 Algorithms (http://docs.aws.amazon.com/sagemaker/latest/dg/algos.html).
	// For information about providing your own algorithms, see your-algorithms.
	//
	// AlgorithmSpecification is a required field
	AlgorithmSpecification *AlgorithmSpecification `type:"structure" required:"true"`

	// Algorithm-specific parameters. You set hyperparameters before you start the
	// learning process. Hyperparameters influence the quality of the model. For
	// a list of hyperparameters for each training algorithm provided by Amazon
	// SageMaker, see Algorithms (http://docs.aws.amazon.com/sagemaker/latest/dg/algos.html).
	//
	// 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 Length Constraint.
	HyperParameters map[string]string `type:"map"`

	// An array of Channel objects. Each channel is a named input source. InputDataConfig
	// describes the input data and its location.
	//
	// Algorithms can accept input data from one or more channels. For example,
	// an algorithm might have two channels of input data, training_data and validation_data.
	// The configuration for each channel provides the S3 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.
	//
	// 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.
	//
	// InputDataConfig is a required field
	InputDataConfig []Channel `min:"1" type:"list" required:"true"`

	// Specifies the path to the S3 bucket where you want to store model artifacts.
	// Amazon SageMaker creates subfolders for the artifacts.
	//
	// OutputDataConfig is a required field
	OutputDataConfig *OutputDataConfig `type:"structure" required:"true"`

	// The resources, including the ML compute instances and ML storage volumes,
	// to use for model training.
	//
	// 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 File as the TrainingInputMode in the algorithm specification. For
	// distributed training algorithms, specify an instance count greater than 1.
	//
	// ResourceConfig is a required field
	ResourceConfig *ResourceConfig `type:"structure" required:"true"`

	// The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume
	// to perform tasks on your behalf.
	//
	// 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 Amazon SageMaker Roles
	// (http://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html).
	//
	// RoleArn is a required field
	RoleArn *string `min:"20" type:"string" required:"true"`

	// Sets a duration for training. Use this parameter to cap model training costs.
	// To stop a job, Amazon SageMaker sends the algorithm the SIGTERM signal, which
	// delays job termination for 120 seconds. Algorithms might use this 120-second
	// window to save the model artifacts.
	//
	// When Amazon SageMaker terminates a job because the stopping condition has
	// been met, training algorithms provided by Amazon SageMaker save the intermediate
	// results of the job. This intermediate data is a valid model artifact. You
	// can use it to create a model using the CreateModel API.
	//
	// StoppingCondition is a required field
	StoppingCondition *StoppingCondition `type:"structure" required:"true"`

	// An array of key-value pairs. For more information, see Using Cost Allocation
	// Tags (http://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-what)
	// in the AWS Billing and Cost Management User Guide.
	Tags []Tag `type:"list"`

	// The name of the training job. The name must be unique within an AWS Region
	// in an AWS account. It appears in the Amazon SageMaker console.
	//
	// TrainingJobName is a required field
	TrainingJobName *string `min:"1" type:"string" required:"true"`

	// 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 train-vpc
	VpcConfig *VpcConfig `type:"structure"`
}

// String returns the string representation
func (s CreateTrainingJobInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateTrainingJobInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateTrainingJobInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateTrainingJobInput"}

	if s.AlgorithmSpecification == nil {
		invalidParams.Add(aws.NewErrParamRequired("AlgorithmSpecification"))
	}

	if s.InputDataConfig == nil {
		invalidParams.Add(aws.NewErrParamRequired("InputDataConfig"))
	}
	if s.InputDataConfig != nil && len(s.InputDataConfig) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("InputDataConfig", 1))
	}

	if s.OutputDataConfig == nil {
		invalidParams.Add(aws.NewErrParamRequired("OutputDataConfig"))
	}

	if s.ResourceConfig == nil {
		invalidParams.Add(aws.NewErrParamRequired("ResourceConfig"))
	}

	if s.RoleArn == nil {
		invalidParams.Add(aws.NewErrParamRequired("RoleArn"))
	}
	if s.RoleArn != nil && len(*s.RoleArn) < 20 {
		invalidParams.Add(aws.NewErrParamMinLen("RoleArn", 20))
	}

	if s.StoppingCondition == nil {
		invalidParams.Add(aws.NewErrParamRequired("StoppingCondition"))
	}

	if s.TrainingJobName == nil {
		invalidParams.Add(aws.NewErrParamRequired("TrainingJobName"))
	}
	if s.TrainingJobName != nil && len(*s.TrainingJobName) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("TrainingJobName", 1))
	}
	if s.AlgorithmSpecification != nil {
		if err := s.AlgorithmSpecification.Validate(); err != nil {
			invalidParams.AddNested("AlgorithmSpecification", err.(aws.ErrInvalidParams))
		}
	}
	if s.InputDataConfig != nil {
		for i, v := range s.InputDataConfig {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "InputDataConfig", i), err.(aws.ErrInvalidParams))
			}
		}
	}
	if s.OutputDataConfig != nil {
		if err := s.OutputDataConfig.Validate(); err != nil {
			invalidParams.AddNested("OutputDataConfig", err.(aws.ErrInvalidParams))
		}
	}
	if s.ResourceConfig != nil {
		if err := s.ResourceConfig.Validate(); err != nil {
			invalidParams.AddNested("ResourceConfig", err.(aws.ErrInvalidParams))
		}
	}
	if s.StoppingCondition != nil {
		if err := s.StoppingCondition.Validate(); err != nil {
			invalidParams.AddNested("StoppingCondition", err.(aws.ErrInvalidParams))
		}
	}
	if s.Tags != nil {
		for i, v := range s.Tags {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(aws.ErrInvalidParams))
			}
		}
	}
	if s.VpcConfig != nil {
		if err := s.VpcConfig.Validate(); err != nil {
			invalidParams.AddNested("VpcConfig", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/CreateTrainingJobResponse
type CreateTrainingJobOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The Amazon Resource Name (ARN) of the training job.
	//
	// TrainingJobArn is a required field
	TrainingJobArn *string `type:"string" required:"true"`
}

// String returns the string representation
func (s CreateTrainingJobOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateTrainingJobOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateTrainingJobOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Describes the location of the channel data.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DataSource
type DataSource struct {
	_ struct{} `type:"structure"`

	// The S3 location of the data source that is associated with a channel.
	//
	// S3DataSource is a required field
	S3DataSource *S3DataSource `type:"structure" required:"true"`
}

// String returns the string representation
func (s DataSource) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DataSource) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DataSource) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DataSource"}

	if s.S3DataSource == nil {
		invalidParams.Add(aws.NewErrParamRequired("S3DataSource"))
	}
	if s.S3DataSource != nil {
		if err := s.S3DataSource.Validate(); err != nil {
			invalidParams.AddNested("S3DataSource", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteEndpointConfigInput
type DeleteEndpointConfigInput struct {
	_ struct{} `type:"structure"`

	// The name of the endpoint configuration that you want to delete.
	//
	// EndpointConfigName is a required field
	EndpointConfigName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteEndpointConfigInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteEndpointConfigInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteEndpointConfigInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteEndpointConfigInput"}

	if s.EndpointConfigName == nil {
		invalidParams.Add(aws.NewErrParamRequired("EndpointConfigName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteEndpointConfigOutput
type DeleteEndpointConfigOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s DeleteEndpointConfigOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteEndpointConfigOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteEndpointConfigOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteEndpointInput
type DeleteEndpointInput struct {
	_ struct{} `type:"structure"`

	// The name of the endpoint that you want to delete.
	//
	// EndpointName is a required field
	EndpointName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteEndpointInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteEndpointInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteEndpointInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteEndpointInput"}

	if s.EndpointName == nil {
		invalidParams.Add(aws.NewErrParamRequired("EndpointName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteEndpointOutput
type DeleteEndpointOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s DeleteEndpointOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteEndpointOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteEndpointOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteModelInput
type DeleteModelInput struct {
	_ struct{} `type:"structure"`

	// The name of the model to delete.
	//
	// ModelName is a required field
	ModelName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteModelInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteModelInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteModelInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteModelInput"}

	if s.ModelName == nil {
		invalidParams.Add(aws.NewErrParamRequired("ModelName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteModelOutput
type DeleteModelOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s DeleteModelOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteModelOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteModelOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteNotebookInstanceInput
type DeleteNotebookInstanceInput struct {
	_ struct{} `type:"structure"`

	// The name of the Amazon SageMaker notebook instance to delete.
	//
	// NotebookInstanceName is a required field
	NotebookInstanceName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteNotebookInstanceInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteNotebookInstanceInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteNotebookInstanceInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteNotebookInstanceInput"}

	if s.NotebookInstanceName == nil {
		invalidParams.Add(aws.NewErrParamRequired("NotebookInstanceName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteNotebookInstanceLifecycleConfigInput
type DeleteNotebookInstanceLifecycleConfigInput struct {
	_ struct{} `type:"structure"`

	// The name of the lifecycle configuration to delete.
	//
	// NotebookInstanceLifecycleConfigName is a required field
	NotebookInstanceLifecycleConfigName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteNotebookInstanceLifecycleConfigInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteNotebookInstanceLifecycleConfigInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteNotebookInstanceLifecycleConfigInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteNotebookInstanceLifecycleConfigInput"}

	if s.NotebookInstanceLifecycleConfigName == nil {
		invalidParams.Add(aws.NewErrParamRequired("NotebookInstanceLifecycleConfigName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteNotebookInstanceLifecycleConfigOutput
type DeleteNotebookInstanceLifecycleConfigOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s DeleteNotebookInstanceLifecycleConfigOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteNotebookInstanceLifecycleConfigOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteNotebookInstanceLifecycleConfigOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteNotebookInstanceOutput
type DeleteNotebookInstanceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s DeleteNotebookInstanceOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteNotebookInstanceOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteNotebookInstanceOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteTagsInput
type DeleteTagsInput struct {
	_ struct{} `type:"structure"`

	// The Amazon Resource Name (ARN) of the resource whose tags you want to delete.
	//
	// ResourceArn is a required field
	ResourceArn *string `type:"string" required:"true"`

	// An array or one or more tag keys to delete.
	//
	// TagKeys is a required field
	TagKeys []string `min:"1" type:"list" required:"true"`
}

// String returns the string representation
func (s DeleteTagsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteTagsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteTagsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteTagsInput"}

	if s.ResourceArn == nil {
		invalidParams.Add(aws.NewErrParamRequired("ResourceArn"))
	}

	if s.TagKeys == nil {
		invalidParams.Add(aws.NewErrParamRequired("TagKeys"))
	}
	if s.TagKeys != nil && len(s.TagKeys) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("TagKeys", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DeleteTagsOutput
type DeleteTagsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s DeleteTagsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteTagsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteTagsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeEndpointConfigInput
type DescribeEndpointConfigInput struct {
	_ struct{} `type:"structure"`

	// The name of the endpoint configuration.
	//
	// EndpointConfigName is a required field
	EndpointConfigName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DescribeEndpointConfigInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeEndpointConfigInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeEndpointConfigInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeEndpointConfigInput"}

	if s.EndpointConfigName == nil {
		invalidParams.Add(aws.NewErrParamRequired("EndpointConfigName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeEndpointConfigOutput
type DescribeEndpointConfigOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// A timestamp that shows when the endpoint configuration was created.
	//
	// CreationTime is a required field
	CreationTime *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`

	// The Amazon Resource Name (ARN) of the endpoint configuration.
	//
	// EndpointConfigArn is a required field
	EndpointConfigArn *string `min:"20" type:"string" required:"true"`

	// Name of the Amazon SageMaker endpoint configuration.
	//
	// EndpointConfigName is a required field
	EndpointConfigName *string `type:"string" required:"true"`

	// AWS KMS key ID Amazon SageMaker uses to encrypt data when storing it on the
	// ML storage volume attached to the instance.
	KmsKeyId *string `type:"string"`

	// An array of ProductionVariant objects, one for each model that you want to
	// host at this endpoint.
	//
	// ProductionVariants is a required field
	ProductionVariants []ProductionVariant `min:"1" type:"list" required:"true"`
}

// String returns the string representation
func (s DescribeEndpointConfigOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeEndpointConfigOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeEndpointConfigOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeEndpointInput
type DescribeEndpointInput struct {
	_ struct{} `type:"structure"`

	// The name of the endpoint.
	//
	// EndpointName is a required field
	EndpointName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DescribeEndpointInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeEndpointInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeEndpointInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeEndpointInput"}

	if s.EndpointName == nil {
		invalidParams.Add(aws.NewErrParamRequired("EndpointName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeEndpointOutput
type DescribeEndpointOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// A timestamp that shows when the endpoint was created.
	//
	// CreationTime is a required field
	CreationTime *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`

	// The Amazon Resource Name (ARN) of the endpoint.
	//
	// EndpointArn is a required field
	EndpointArn *string `min:"20" type:"string" required:"true"`

	// The name of the endpoint configuration associated with this endpoint.
	//
	// EndpointConfigName is a required field
	EndpointConfigName *string `type:"string" required:"true"`

	// Name of the endpoint.
	//
	// EndpointName is a required field
	EndpointName *string `type:"string" required:"true"`

	// The status of the endpoint.
	//
	// EndpointStatus is a required field
	EndpointStatus EndpointStatus `type:"string" required:"true" enum:"true"`

	// If the status of the endpoint is Failed, the reason why it failed.
	FailureReason *string `type:"string"`

	// A timestamp that shows when the endpoint was last modified.
	//
	// LastModifiedTime is a required field
	LastModifiedTime *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`

	// An array of ProductionVariant objects, one for each model hosted behind this
	// endpoint.
	ProductionVariants []ProductionVariantSummary `min:"1" type:"list"`
}

// String returns the string representation
func (s DescribeEndpointOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeEndpointOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeEndpointOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeModelInput
type DescribeModelInput struct {
	_ struct{} `type:"structure"`

	// The name of the model.
	//
	// ModelName is a required field
	ModelName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DescribeModelInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeModelInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeModelInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeModelInput"}

	if s.ModelName == nil {
		invalidParams.Add(aws.NewErrParamRequired("ModelName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeModelOutput
type DescribeModelOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// A timestamp that shows when the model was created.
	//
	// CreationTime is a required field
	CreationTime *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`

	// The Amazon Resource Name (ARN) of the IAM role that you specified for the
	// model.
	//
	// ExecutionRoleArn is a required field
	ExecutionRoleArn *string `min:"20" type:"string" required:"true"`

	// The Amazon Resource Name (ARN) of the model.
	//
	// ModelArn is a required field
	ModelArn *string `min:"20" type:"string" required:"true"`

	// Name of the Amazon SageMaker model.
	//
	// ModelName is a required field
	ModelName *string `type:"string" required:"true"`

	// The location of the primary inference code, associated artifacts, and custom
	// environment map that the inference code uses when it is deployed in production.
	//
	// PrimaryContainer is a required field
	PrimaryContainer *ContainerDefinition `type:"structure" required:"true"`

	// A object that specifies the VPC that this model has access to. For more information,
	// see host-vpc
	VpcConfig *VpcConfig `type:"structure"`
}

// String returns the string representation
func (s DescribeModelOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeModelOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeModelOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeNotebookInstanceInput
type DescribeNotebookInstanceInput struct {
	_ struct{} `type:"structure"`

	// The name of the notebook instance that you want information about.
	//
	// NotebookInstanceName is a required field
	NotebookInstanceName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DescribeNotebookInstanceInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeNotebookInstanceInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeNotebookInstanceInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeNotebookInstanceInput"}

	if s.NotebookInstanceName == nil {
		invalidParams.Add(aws.NewErrParamRequired("NotebookInstanceName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeNotebookInstanceLifecycleConfigInput
type DescribeNotebookInstanceLifecycleConfigInput struct {
	_ struct{} `type:"structure"`

	// The name of the lifecycle configuration to describe.
	//
	// NotebookInstanceLifecycleConfigName is a required field
	NotebookInstanceLifecycleConfigName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DescribeNotebookInstanceLifecycleConfigInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeNotebookInstanceLifecycleConfigInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeNotebookInstanceLifecycleConfigInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeNotebookInstanceLifecycleConfigInput"}

	if s.NotebookInstanceLifecycleConfigName == nil {
		invalidParams.Add(aws.NewErrParamRequired("NotebookInstanceLifecycleConfigName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeNotebookInstanceLifecycleConfigOutput
type DescribeNotebookInstanceLifecycleConfigOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// A timestamp that tells when the lifecycle configuration was created.
	CreationTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A timestamp that tells when the lifecycle configuration was last modified.
	LastModifiedTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The Amazon Resource Name (ARN) of the lifecycle configuration.
	NotebookInstanceLifecycleConfigArn *string `type:"string"`

	// The name of the lifecycle configuration.
	NotebookInstanceLifecycleConfigName *string `type:"string"`

	// The shell script that runs only once, when you create a notebook instance.
	OnCreate []NotebookInstanceLifecycleHook `type:"list"`

	// The shell script that runs every time you start a notebook instance, including
	// when you create the notebook instance.
	OnStart []NotebookInstanceLifecycleHook `type:"list"`
}

// String returns the string representation
func (s DescribeNotebookInstanceLifecycleConfigOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeNotebookInstanceLifecycleConfigOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeNotebookInstanceLifecycleConfigOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeNotebookInstanceOutput
type DescribeNotebookInstanceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// A timestamp. Use this parameter to return the time when the notebook instance
	// was created
	CreationTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// Describes whether Amazon SageMaker provides internet access to the notebook
	// instance. If this value is set to Disabled, he notebook instance does not
	// have internet access, and cannot connect to Amazon SageMaker training and
	// endpoint services.
	//
	// For more information, see appendix-notebook-and-internet-access.
	DirectInternetAccess DirectInternetAccess `type:"string" enum:"true"`

	// If status is failed, the reason it failed.
	FailureReason *string `type:"string"`

	// The type of ML compute instance running on the notebook instance.
	InstanceType InstanceType `type:"string" enum:"true"`

	// AWS KMS key ID Amazon SageMaker uses to encrypt data when storing it on the
	// ML storage volume attached to the instance.
	KmsKeyId *string `type:"string"`

	// A timestamp. Use this parameter to retrieve the time when the notebook instance
	// was last modified.
	LastModifiedTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// Network interface IDs that Amazon SageMaker created at the time of creating
	// the instance.
	NetworkInterfaceId *string `type:"string"`

	// The Amazon Resource Name (ARN) of the notebook instance.
	NotebookInstanceArn *string `type:"string"`

	// Returns the name of a notebook instance lifecycle configuration.
	//
	// For information about notebook instance lifestyle configurations, see notebook-lifecycle-config.
	NotebookInstanceLifecycleConfigName *string `type:"string"`

	// Name of the Amazon SageMaker notebook instance.
	NotebookInstanceName *string `type:"string"`

	// The status of the notebook instance.
	NotebookInstanceStatus NotebookInstanceStatus `type:"string" enum:"true"`

	// Amazon Resource Name (ARN) of the IAM role associated with the instance.
	RoleArn *string `min:"20" type:"string"`

	// The IDs of the VPC security groups.
	SecurityGroups []string `type:"list"`

	// The ID of the VPC subnet.
	SubnetId *string `type:"string"`

	// The URL that you use to connect to the Jupyter notebook that is running in
	// your notebook instance.
	Url *string `type:"string"`
}

// String returns the string representation
func (s DescribeNotebookInstanceOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeNotebookInstanceOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeNotebookInstanceOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeTrainingJobRequest
type DescribeTrainingJobInput struct {
	_ struct{} `type:"structure"`

	// The name of the training job.
	//
	// TrainingJobName is a required field
	TrainingJobName *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s DescribeTrainingJobInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeTrainingJobInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeTrainingJobInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeTrainingJobInput"}

	if s.TrainingJobName == nil {
		invalidParams.Add(aws.NewErrParamRequired("TrainingJobName"))
	}
	if s.TrainingJobName != nil && len(*s.TrainingJobName) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("TrainingJobName", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DescribeTrainingJobResponse
type DescribeTrainingJobOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the algorithm used for training, and algorithm metadata.
	//
	// AlgorithmSpecification is a required field
	AlgorithmSpecification *AlgorithmSpecification `type:"structure" required:"true"`

	// A timestamp that indicates when the training job was created.
	//
	// CreationTime is a required field
	CreationTime *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`

	// If the training job failed, the reason it failed.
	FailureReason *string `type:"string"`

	// Algorithm-specific parameters.
	HyperParameters map[string]string `type:"map"`

	// An array of Channel objects that describes each data input channel.
	//
	// InputDataConfig is a required field
	InputDataConfig []Channel `min:"1" type:"list" required:"true"`

	// A timestamp that indicates when the status of the training job was last modified.
	LastModifiedTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// Information about the Amazon S3 location that is configured for storing model
	// artifacts.
	//
	// ModelArtifacts is a required field
	ModelArtifacts *ModelArtifacts `type:"structure" required:"true"`

	// The S3 path where model artifacts that you configured when creating the job
	// are stored. Amazon SageMaker creates subfolders for model artifacts.
	OutputDataConfig *OutputDataConfig `type:"structure"`

	// Resources, including ML compute instances and ML storage volumes, that are
	// configured for model training.
	//
	// ResourceConfig is a required field
	ResourceConfig *ResourceConfig `type:"structure" required:"true"`

	// The AWS Identity and Access Management (IAM) role configured for the training
	// job.
	RoleArn *string `min:"20" type:"string"`

	// Provides granular information about the system state. For more information,
	// see TrainingJobStatus.
	//
	// SecondaryStatus is a required field
	SecondaryStatus SecondaryStatus `type:"string" required:"true" enum:"true"`

	// The condition under which to stop the training job.
	//
	// StoppingCondition is a required field
	StoppingCondition *StoppingCondition `type:"structure" required:"true"`

	// A timestamp that indicates when model training ended.
	TrainingEndTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The Amazon Resource Name (ARN) of the training job.
	//
	// TrainingJobArn is a required field
	TrainingJobArn *string `type:"string" required:"true"`

	// Name of the model training job.
	//
	// TrainingJobName is a required field
	TrainingJobName *string `min:"1" type:"string" required:"true"`

	// The status of the training job.
	//
	// For the InProgress status, Amazon SageMaker can return these secondary statuses:
	//
	//    * Starting - Preparing for training.
	//
	//    * Downloading - Optional stage for algorithms that support File training
	//    input mode. It indicates data is being downloaded to ML storage volumes.
	//
	//    * Training - Training is in progress.
	//
	//    * Uploading - Training is complete and model upload is in progress.
	//
	// For the Stopped training status, Amazon SageMaker can return these secondary
	// statuses:
	//
	//    * MaxRuntimeExceeded - Job stopped as a result of maximum allowed runtime
	//    exceeded.
	//
	// TrainingJobStatus is a required field
	TrainingJobStatus TrainingJobStatus `type:"string" required:"true" enum:"true"`

	// A timestamp that indicates when training started.
	TrainingStartTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A object that specifies the VPC that this training job has access to. For
	// more information, see train-vpc.
	VpcConfig *VpcConfig `type:"structure"`
}

// String returns the string representation
func (s DescribeTrainingJobOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeTrainingJobOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeTrainingJobOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Specifies weight and capacity values for a production variant.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/DesiredWeightAndCapacity
type DesiredWeightAndCapacity struct {
	_ struct{} `type:"structure"`

	// The variant's capacity.
	DesiredInstanceCount *int64 `min:"1" type:"integer"`

	// The variant's weight.
	DesiredWeight *float64 `type:"float"`

	// The name of the variant to update.
	//
	// VariantName is a required field
	VariantName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DesiredWeightAndCapacity) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DesiredWeightAndCapacity) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DesiredWeightAndCapacity) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DesiredWeightAndCapacity"}
	if s.DesiredInstanceCount != nil && *s.DesiredInstanceCount < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("DesiredInstanceCount", 1))
	}

	if s.VariantName == nil {
		invalidParams.Add(aws.NewErrParamRequired("VariantName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Provides summary information for an endpoint configuration.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/EndpointConfigSummary
type EndpointConfigSummary struct {
	_ struct{} `type:"structure"`

	// A timestamp that shows when the endpoint configuration was created.
	//
	// CreationTime is a required field
	CreationTime *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`

	// The Amazon Resource Name (ARN) of the endpoint configuration.
	//
	// EndpointConfigArn is a required field
	EndpointConfigArn *string `min:"20" type:"string" required:"true"`

	// The name of the endpoint configuration.
	//
	// EndpointConfigName is a required field
	EndpointConfigName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s EndpointConfigSummary) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s EndpointConfigSummary) GoString() string {
	return s.String()
}

// Provides summary information for an endpoint.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/EndpointSummary
type EndpointSummary struct {
	_ struct{} `type:"structure"`

	// A timestamp that shows when the endpoint was created.
	//
	// CreationTime is a required field
	CreationTime *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`

	// The Amazon Resource Name (ARN) of the endpoint.
	//
	// EndpointArn is a required field
	EndpointArn *string `min:"20" type:"string" required:"true"`

	// The name of the endpoint.
	//
	// EndpointName is a required field
	EndpointName *string `type:"string" required:"true"`

	// The status of the endpoint.
	//
	// EndpointStatus is a required field
	EndpointStatus EndpointStatus `type:"string" required:"true" enum:"true"`

	// A timestamp that shows when the endpoint was last modified.
	//
	// LastModifiedTime is a required field
	LastModifiedTime *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`
}

// String returns the string representation
func (s EndpointSummary) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s EndpointSummary) GoString() string {
	return s.String()
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListEndpointConfigsInput
type ListEndpointConfigsInput struct {
	_ struct{} `type:"structure"`

	// A filter that returns only endpoint configurations created after the specified
	// time (timestamp).
	CreationTimeAfter *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A filter that returns only endpoint configurations created before the specified
	// time (timestamp).
	CreationTimeBefore *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The maximum number of training jobs to return in the response.
	MaxResults *int64 `min:"1" type:"integer"`

	// A string in the endpoint configuration name. This filter returns only endpoint
	// configurations whose name contains the specified string.
	NameContains *string `type:"string"`

	// If the result of the previous ListEndpointConfig request was truncated, the
	// response includes a NextToken. To retrieve the next set of endpoint configurations,
	// use the token in the next request.
	NextToken *string `type:"string"`

	// The field to sort results by. The default is CreationTime.
	SortBy EndpointConfigSortKey `type:"string" enum:"true"`

	// The sort order for results. The default is Ascending.
	SortOrder OrderKey `type:"string" enum:"true"`
}

// String returns the string representation
func (s ListEndpointConfigsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListEndpointConfigsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListEndpointConfigsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListEndpointConfigsInput"}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("MaxResults", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListEndpointConfigsOutput
type ListEndpointConfigsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// An array of endpoint configurations.
	//
	// EndpointConfigs is a required field
	EndpointConfigs []EndpointConfigSummary `type:"list" required:"true"`

	// If the response is truncated, Amazon SageMaker returns this token. To retrieve
	// the next set of endpoint configurations, use it in the subsequent request
	NextToken *string `type:"string"`
}

// String returns the string representation
func (s ListEndpointConfigsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListEndpointConfigsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListEndpointConfigsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListEndpointsInput
type ListEndpointsInput struct {
	_ struct{} `type:"structure"`

	// A filter that returns only endpoints that were created after the specified
	// time (timestamp).
	CreationTimeAfter *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A filter that returns only endpoints that were created before the specified
	// time (timestamp).
	CreationTimeBefore *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A filter that returns only endpoints that were modified after the specified
	// timestamp.
	LastModifiedTimeAfter *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A filter that returns only endpoints that were modified before the specified
	// timestamp.
	LastModifiedTimeBefore *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The maximum number of endpoints to return in the response.
	MaxResults *int64 `min:"1" type:"integer"`

	// A string in endpoint names. This filter returns only endpoints whose name
	// contains the specified string.
	NameContains *string `type:"string"`

	// If the result of a ListEndpoints request was truncated, the response includes
	// a NextToken. To retrieve the next set of endpoints, use the token in the
	// next request.
	NextToken *string `type:"string"`

	// Sorts the list of results. The default is CreationTime.
	SortBy EndpointSortKey `type:"string" enum:"true"`

	// The sort order for results. The default is Ascending.
	SortOrder OrderKey `type:"string" enum:"true"`

	// A filter that returns only endpoints with the specified status.
	StatusEquals EndpointStatus `type:"string" enum:"true"`
}

// String returns the string representation
func (s ListEndpointsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListEndpointsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListEndpointsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListEndpointsInput"}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("MaxResults", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListEndpointsOutput
type ListEndpointsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// An array or endpoint objects.
	//
	// Endpoints is a required field
	Endpoints []EndpointSummary `type:"list" required:"true"`

	// If the response is truncated, Amazon SageMaker returns this token. To retrieve
	// the next set of training jobs, use it in the subsequent request.
	NextToken *string `type:"string"`
}

// String returns the string representation
func (s ListEndpointsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListEndpointsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListEndpointsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListModelsInput
type ListModelsInput struct {
	_ struct{} `type:"structure"`

	// A filter that returns only models created after the specified time (timestamp).
	CreationTimeAfter *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A filter that returns only models created before the specified time (timestamp).
	CreationTimeBefore *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The maximum number of models to return in the response.
	MaxResults *int64 `min:"1" type:"integer"`

	// A string in the training job name. This filter returns only models in the
	// training job whose name contains the specified string.
	NameContains *string `type:"string"`

	// If the response to a previous ListModels request was truncated, the response
	// includes a NextToken. To retrieve the next set of models, use the token in
	// the next request.
	NextToken *string `type:"string"`

	// Sorts the list of results. The default is CreationTime.
	SortBy ModelSortKey `type:"string" enum:"true"`

	// The sort order for results. The default is Ascending.
	SortOrder OrderKey `type:"string" enum:"true"`
}

// String returns the string representation
func (s ListModelsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListModelsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListModelsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListModelsInput"}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("MaxResults", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListModelsOutput
type ListModelsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// An array of ModelSummary objects, each of which lists a model.
	//
	// Models is a required field
	Models []ModelSummary `type:"list" required:"true"`

	// If the response is truncated, Amazon SageMaker returns this token. To retrieve
	// the next set of models, use it in the subsequent request.
	NextToken *string `type:"string"`
}

// String returns the string representation
func (s ListModelsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListModelsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListModelsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListNotebookInstanceLifecycleConfigsInput
type ListNotebookInstanceLifecycleConfigsInput struct {
	_ struct{} `type:"structure"`

	// A filter that returns only lifecycle configurations that were created after
	// the specified time (timestamp).
	CreationTimeAfter *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A filter that returns only lifecycle configurations that were created before
	// the specified time (timestamp).
	CreationTimeBefore *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A filter that returns only lifecycle configurations that were modified after
	// the specified time (timestamp).
	LastModifiedTimeAfter *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A filter that returns only lifecycle configurations that were modified before
	// the specified time (timestamp).
	LastModifiedTimeBefore *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The maximum number of lifecycle configurations to return in the response.
	MaxResults *int64 `min:"1" type:"integer"`

	// A string in the lifecycle configuration name. This filter returns only lifecycle
	// configurations whose name contains the specified string.
	NameContains *string `type:"string"`

	// If the result of a ListNotebookInstanceLifecycleConfigs request was truncated,
	// the response includes a NextToken. To get the next set of lifecycle configurations,
	// use the token in the next request.
	NextToken *string `type:"string"`

	// Sorts the list of results. The default is CreationTime.
	SortBy NotebookInstanceLifecycleConfigSortKey `type:"string" enum:"true"`

	// The sort order for results.
	SortOrder NotebookInstanceLifecycleConfigSortOrder `type:"string" enum:"true"`
}

// String returns the string representation
func (s ListNotebookInstanceLifecycleConfigsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListNotebookInstanceLifecycleConfigsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListNotebookInstanceLifecycleConfigsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListNotebookInstanceLifecycleConfigsInput"}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("MaxResults", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListNotebookInstanceLifecycleConfigsOutput
type ListNotebookInstanceLifecycleConfigsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// If the response is truncated, Amazon SageMaker returns this token. To get
	// the next set of lifecycle configurations, use it in the next request.
	NextToken *string `type:"string"`

	// An array of NotebookInstanceLifecycleConfiguration objects, each listing
	// a lifecycle configuration.
	NotebookInstanceLifecycleConfigs []NotebookInstanceLifecycleConfigSummary `type:"list"`
}

// String returns the string representation
func (s ListNotebookInstanceLifecycleConfigsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListNotebookInstanceLifecycleConfigsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListNotebookInstanceLifecycleConfigsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListNotebookInstancesInput
type ListNotebookInstancesInput struct {
	_ struct{} `type:"structure"`

	// A filter that returns only notebook instances that were created after the
	// specified time (timestamp).
	CreationTimeAfter *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A filter that returns only notebook instances that were created before the
	// specified time (timestamp).
	CreationTimeBefore *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A filter that returns only notebook instances that were modified after the
	// specified time (timestamp).
	LastModifiedTimeAfter *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A filter that returns only notebook instances that were modified before the
	// specified time (timestamp).
	LastModifiedTimeBefore *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The maximum number of notebook instances to return.
	MaxResults *int64 `min:"1" type:"integer"`

	// A string in the notebook instances' name. This filter returns only notebook
	// instances whose name contains the specified string.
	NameContains *string `type:"string"`

	// If the previous call to the ListNotebookInstances is truncated, the response
	// includes a NextToken. You can use this token in your subsequent ListNotebookInstances
	// request to fetch the next set of notebook instances.
	//
	// 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.
	NextToken *string `type:"string"`

	// 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.
	NotebookInstanceLifecycleConfigNameContains *string `type:"string"`

	// The field to sort results by. The default is Name.
	SortBy NotebookInstanceSortKey `type:"string" enum:"true"`

	// The sort order for results.
	SortOrder NotebookInstanceSortOrder `type:"string" enum:"true"`

	// A filter that returns only notebook instances with the specified status.
	StatusEquals NotebookInstanceStatus `type:"string" enum:"true"`
}

// String returns the string representation
func (s ListNotebookInstancesInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListNotebookInstancesInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListNotebookInstancesInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListNotebookInstancesInput"}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("MaxResults", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListNotebookInstancesOutput
type ListNotebookInstancesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// If the response to the previous ListNotebookInstances request was truncated,
	// Amazon SageMaker returns this token. To retrieve the next set of notebook
	// instances, use the token in the next request.
	NextToken *string `type:"string"`

	// An array of NotebookInstanceSummary objects, one for each notebook instance.
	NotebookInstances []NotebookInstanceSummary `type:"list"`
}

// String returns the string representation
func (s ListNotebookInstancesOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListNotebookInstancesOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListNotebookInstancesOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListTagsInput
type ListTagsInput struct {
	_ struct{} `type:"structure"`

	// Maximum number of tags to return.
	MaxResults *int64 `min:"50" type:"integer"`

	// If the response to the previous ListTags request is truncated, Amazon SageMaker
	// returns this token. To retrieve the next set of tags, use it in the subsequent
	// request.
	NextToken *string `type:"string"`

	// The Amazon Resource Name (ARN) of the resource whose tags you want to retrieve.
	//
	// ResourceArn is a required field
	ResourceArn *string `type:"string" required:"true"`
}

// String returns the string representation
func (s ListTagsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListTagsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListTagsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListTagsInput"}
	if s.MaxResults != nil && *s.MaxResults < 50 {
		invalidParams.Add(aws.NewErrParamMinValue("MaxResults", 50))
	}

	if s.ResourceArn == nil {
		invalidParams.Add(aws.NewErrParamRequired("ResourceArn"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListTagsOutput
type ListTagsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// 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.
	NextToken *string `type:"string"`

	// An array of Tag objects, each with a tag key and a value.
	Tags []Tag `type:"list"`
}

// String returns the string representation
func (s ListTagsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListTagsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListTagsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListTrainingJobsRequest
type ListTrainingJobsInput struct {
	_ struct{} `type:"structure"`

	// A filter that only training jobs created after the specified time (timestamp).
	CreationTimeAfter *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A filter that returns only training jobs created before the specified time
	// (timestamp).
	CreationTimeBefore *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A filter that returns only training jobs modified after the specified time
	// (timestamp).
	LastModifiedTimeAfter *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A filter that returns only training jobs modified before the specified time
	// (timestamp).
	LastModifiedTimeBefore *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The maximum number of training jobs to return in the response.
	MaxResults *int64 `min:"1" type:"integer"`

	// A string in the training job name. This filter returns only models whose
	// name contains the specified string.
	NameContains *string `type:"string"`

	// If the result of the previous ListTrainingJobs request was truncated, the
	// response includes a NextToken. To retrieve the next set of training jobs,
	// use the token in the next request.
	NextToken *string `type:"string"`

	// The field to sort results by. The default is CreationTime.
	SortBy SortBy `type:"string" enum:"true"`

	// The sort order for results. The default is Ascending.
	SortOrder SortOrder `type:"string" enum:"true"`

	// A filter that retrieves only training jobs with a specific status.
	StatusEquals TrainingJobStatus `type:"string" enum:"true"`
}

// String returns the string representation
func (s ListTrainingJobsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListTrainingJobsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListTrainingJobsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListTrainingJobsInput"}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("MaxResults", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ListTrainingJobsResponse
type ListTrainingJobsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// If the response is truncated, Amazon SageMaker returns this token. To retrieve
	// the next set of training jobs, use it in the subsequent request.
	NextToken *string `type:"string"`

	// An array of TrainingJobSummary objects, each listing a training job.
	//
	// TrainingJobSummaries is a required field
	TrainingJobSummaries []TrainingJobSummary `type:"list" required:"true"`
}

// String returns the string representation
func (s ListTrainingJobsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListTrainingJobsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListTrainingJobsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Provides information about the location that is configured for storing model
// artifacts.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ModelArtifacts
type ModelArtifacts struct {
	_ struct{} `type:"structure"`

	// The path of the S3 object that contains the model artifacts. For example,
	// s3://bucket-name/keynameprefix/model.tar.gz.
	//
	// S3ModelArtifacts is a required field
	S3ModelArtifacts *string `type:"string" required:"true"`
}

// String returns the string representation
func (s ModelArtifacts) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ModelArtifacts) GoString() string {
	return s.String()
}

// Provides summary information about a model.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ModelSummary
type ModelSummary struct {
	_ struct{} `type:"structure"`

	// A timestamp that indicates when the model was created.
	//
	// CreationTime is a required field
	CreationTime *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`

	// The Amazon Resource Name (ARN) of the model.
	//
	// ModelArn is a required field
	ModelArn *string `min:"20" type:"string" required:"true"`

	// The name of the model that you want a summary for.
	//
	// ModelName is a required field
	ModelName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s ModelSummary) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ModelSummary) GoString() string {
	return s.String()
}

// Provides a summary of a notebook instance lifecycle configuration.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/NotebookInstanceLifecycleConfigSummary
type NotebookInstanceLifecycleConfigSummary struct {
	_ struct{} `type:"structure"`

	// A timestamp that tells when the lifecycle configuration was created.
	CreationTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A timestamp that tells when the lifecycle configuration was last modified.
	LastModifiedTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The Amazon Resource Name (ARN) of the lifecycle configuration.
	//
	// NotebookInstanceLifecycleConfigArn is a required field
	NotebookInstanceLifecycleConfigArn *string `type:"string" required:"true"`

	// The name of the lifecycle configuration.
	//
	// NotebookInstanceLifecycleConfigName is a required field
	NotebookInstanceLifecycleConfigName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s NotebookInstanceLifecycleConfigSummary) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s NotebookInstanceLifecycleConfigSummary) GoString() string {
	return s.String()
}

// Contains the notebook instance lifecycle configuration script.
//
// Each lifecycle configuration script has a limit of 16384 characters.
//
// The value of the $PATH environment variable that is available to both scripts
// is /sbin:bin:/usr/sbin:/usr/bin.
//
// View CloudWatch Logs for notebook instance lifecycle configurations in log
// group /aws/sagemaker/NotebookInstances in log stream [notebook-instance-name]/[LifecycleConfigHook].
//
// Lifecycle configuration scripts cannot run for longer than 5 minutes. If
// a script runs for longer than 5 minutes, it fails and the notebook instance
// is not created or started.
//
// For information about notebook instance lifestyle configurations, see notebook-lifecycle-config.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/NotebookInstanceLifecycleHook
type NotebookInstanceLifecycleHook struct {
	_ struct{} `type:"structure"`

	// A base64-encoded string that contains a shell script for a notebook instance
	// lifecycle configuration.
	Content *string `min:"1" type:"string"`
}

// String returns the string representation
func (s NotebookInstanceLifecycleHook) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s NotebookInstanceLifecycleHook) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *NotebookInstanceLifecycleHook) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "NotebookInstanceLifecycleHook"}
	if s.Content != nil && len(*s.Content) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Content", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Provides summary information for an Amazon SageMaker notebook instance.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/NotebookInstanceSummary
type NotebookInstanceSummary struct {
	_ struct{} `type:"structure"`

	// A timestamp that shows when the notebook instance was created.
	CreationTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The type of ML compute instance that the notebook instance is running on.
	InstanceType InstanceType `type:"string" enum:"true"`

	// A timestamp that shows when the notebook instance was last modified.
	LastModifiedTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The Amazon Resource Name (ARN) of the notebook instance.
	//
	// NotebookInstanceArn is a required field
	NotebookInstanceArn *string `type:"string" required:"true"`

	// The name of a notebook instance lifecycle configuration associated with this
	// notebook instance.
	//
	// For information about notebook instance lifestyle configurations, see notebook-lifecycle-config.
	NotebookInstanceLifecycleConfigName *string `type:"string"`

	// The name of the notebook instance that you want a summary for.
	//
	// NotebookInstanceName is a required field
	NotebookInstanceName *string `type:"string" required:"true"`

	// The status of the notebook instance.
	NotebookInstanceStatus NotebookInstanceStatus `type:"string" enum:"true"`

	// The URL that you use to connect to the Jupyter instance running in your notebook
	// instance.
	Url *string `type:"string"`
}

// String returns the string representation
func (s NotebookInstanceSummary) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s NotebookInstanceSummary) GoString() string {
	return s.String()
}

// Provides information about how to store model training results (model artifacts).
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/OutputDataConfig
type OutputDataConfig struct {
	_ struct{} `type:"structure"`

	// 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.
	//
	// If the configuration of the output S3 bucket requires server-side encryption
	// for objects, and you don't provide the KMS key ID, Amazon SageMaker uses
	// the default service key. For more information, see KMS-Managed Encryption
	// Keys (https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html)
	// in Amazon Simple Storage Service developer guide.
	//
	// The KMS key policy must grant permission to the IAM role you specify in your
	// CreateTrainingJob request. Using Key Policies in AWS KMS (http://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html)
	// in the AWS Key Management Service Developer Guide.
	KmsKeyId *string `type:"string"`

	// Identifies the S3 path where you want Amazon SageMaker to store the model
	// artifacts. For example, s3://bucket-name/key-name-prefix.
	//
	// S3OutputPath is a required field
	S3OutputPath *string `type:"string" required:"true"`
}

// String returns the string representation
func (s OutputDataConfig) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s OutputDataConfig) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *OutputDataConfig) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "OutputDataConfig"}

	if s.S3OutputPath == nil {
		invalidParams.Add(aws.NewErrParamRequired("S3OutputPath"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// 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.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ProductionVariant
type ProductionVariant struct {
	_ struct{} `type:"structure"`

	// Number of instances to launch initially.
	//
	// InitialInstanceCount is a required field
	InitialInstanceCount *int64 `min:"1" type:"integer" required:"true"`

	// 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 VariantWeight to the sum of all VariantWeight
	// values across all ProductionVariants. If unspecified, it defaults to 1.0.
	InitialVariantWeight *float64 `type:"float"`

	// The ML compute instance type.
	//
	// InstanceType is a required field
	InstanceType ProductionVariantInstanceType `type:"string" required:"true" enum:"true"`

	// The name of the model that you want to host. This is the name that you specified
	// when creating the model.
	//
	// ModelName is a required field
	ModelName *string `type:"string" required:"true"`

	// The name of the production variant.
	//
	// VariantName is a required field
	VariantName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s ProductionVariant) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ProductionVariant) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ProductionVariant) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ProductionVariant"}

	if s.InitialInstanceCount == nil {
		invalidParams.Add(aws.NewErrParamRequired("InitialInstanceCount"))
	}
	if s.InitialInstanceCount != nil && *s.InitialInstanceCount < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("InitialInstanceCount", 1))
	}
	if len(s.InstanceType) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("InstanceType"))
	}

	if s.ModelName == nil {
		invalidParams.Add(aws.NewErrParamRequired("ModelName"))
	}

	if s.VariantName == nil {
		invalidParams.Add(aws.NewErrParamRequired("VariantName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Describes weight and capacities for a production variant associated with
// an endpoint. If you sent a request to the UpdateEndpointWeightsAndCapacities
// API and the endpoint status is Updating, you get different desired and current
// values.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ProductionVariantSummary
type ProductionVariantSummary struct {
	_ struct{} `type:"structure"`

	// The number of instances associated with the variant.
	CurrentInstanceCount *int64 `min:"1" type:"integer"`

	// The weight associated with the variant.
	CurrentWeight *float64 `type:"float"`

	// The number of instances requested in the UpdateEndpointWeightsAndCapacities
	// request.
	DesiredInstanceCount *int64 `min:"1" type:"integer"`

	// The requested weight, as specified in the UpdateEndpointWeightsAndCapacities
	// request.
	DesiredWeight *float64 `type:"float"`

	// The name of the variant.
	//
	// VariantName is a required field
	VariantName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s ProductionVariantSummary) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ProductionVariantSummary) GoString() string {
	return s.String()
}

// Describes the resources, including ML compute instances and ML storage volumes,
// to use for model training.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/ResourceConfig
type ResourceConfig struct {
	_ struct{} `type:"structure"`

	// The number of ML compute instances to use. For distributed training, provide
	// a value greater than 1.
	//
	// InstanceCount is a required field
	InstanceCount *int64 `min:"1" type:"integer" required:"true"`

	// The ML compute instance type.
	//
	// InstanceType is a required field
	InstanceType TrainingInstanceType `type:"string" required:"true" enum:"true"`

	// 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(s) that run the training job.
	VolumeKmsKeyId *string `type:"string"`

	// The size of the ML storage volume that you want to provision.
	//
	// 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 File as
	// the TrainingInputMode in the algorithm specification.
	//
	// You must specify sufficient ML storage for your scenario.
	//
	// Amazon SageMaker supports only the General Purpose SSD (gp2) ML storage volume
	// type.
	//
	// VolumeSizeInGB is a required field
	VolumeSizeInGB *int64 `min:"1" type:"integer" required:"true"`
}

// String returns the string representation
func (s ResourceConfig) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ResourceConfig) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ResourceConfig) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ResourceConfig"}

	if s.InstanceCount == nil {
		invalidParams.Add(aws.NewErrParamRequired("InstanceCount"))
	}
	if s.InstanceCount != nil && *s.InstanceCount < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("InstanceCount", 1))
	}
	if len(s.InstanceType) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("InstanceType"))
	}

	if s.VolumeSizeInGB == nil {
		invalidParams.Add(aws.NewErrParamRequired("VolumeSizeInGB"))
	}
	if s.VolumeSizeInGB != nil && *s.VolumeSizeInGB < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("VolumeSizeInGB", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Describes the S3 data source.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/S3DataSource
type S3DataSource struct {
	_ struct{} `type:"structure"`

	// If you want Amazon SageMaker to replicate the entire dataset on each ML compute
	// instance that is launched for model training, specify FullyReplicated.
	//
	// If you want Amazon SageMaker to replicate a subset of data on each ML compute
	// instance that is launched for model training, specify ShardedByS3Key. If
	// there are n ML compute instances launched for a training job, each instance
	// gets approximately 1/n of the number of S3 objects. In this case, model training
	// on each machine uses only the subset of training data.
	//
	// 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.
	//
	// In distributed training, where you use multiple ML compute EC2 instances,
	// you might choose ShardedByS3Key. If the algorithm requires copying training
	// data to the ML storage volume (when TrainingInputMode is set to File), this
	// copies 1/n of the number of objects.
	S3DataDistributionType S3DataDistribution `type:"string" enum:"true"`

	// If you choose S3Prefix, S3Uri identifies a key name prefix. Amazon SageMaker
	// uses all objects with the specified key name prefix for model training.
	//
	// If you choose ManifestFile, S3Uri identifies an object that is a manifest
	// file containing a list of object keys that you want Amazon SageMaker to use
	// for model training.
	//
	// S3DataType is a required field
	S3DataType S3DataType `type:"string" required:"true" enum:"true"`

	// Depending on the value specified for the S3DataType, identifies either a
	// key name prefix or a manifest. For example:
	//
	//    *  A key name prefix might look like this: s3://bucketname/exampleprefix.
	//
	//
	//    *  A manifest might look like this: s3://bucketname/example.manifest
	//
	//  The manifest is an S3 object which is a JSON file with the following format:
	//
	//
	// [
	//
	//  {"prefix": "s3://customer_bucket/some/prefix/"},
	//
	//  "relative/path/to/custdata-1",
	//
	//  "relative/path/custdata-2",
	//
	//  ...
	//
	//  ]
	//
	//  The preceding JSON matches the following s3Uris:
	//
	// s3://customer_bucket/some/prefix/relative/path/to/custdata-1
	//
	// s3://customer_bucket/some/prefix/relative/path/custdata-1
	//
	// ...
	//
	//  The complete set of s3uris in this manifest constitutes the input data for
	//    the channel for this datasource. The object that each s3uris points to
	//    must readable by the IAM role that Amazon SageMaker uses to perform tasks
	//    on your behalf.
	//
	// S3Uri is a required field
	S3Uri *string `type:"string" required:"true"`
}

// String returns the string representation
func (s S3DataSource) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s S3DataSource) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *S3DataSource) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "S3DataSource"}
	if len(s.S3DataType) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("S3DataType"))
	}

	if s.S3Uri == nil {
		invalidParams.Add(aws.NewErrParamRequired("S3Uri"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/StartNotebookInstanceInput
type StartNotebookInstanceInput struct {
	_ struct{} `type:"structure"`

	// The name of the notebook instance to start.
	//
	// NotebookInstanceName is a required field
	NotebookInstanceName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s StartNotebookInstanceInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StartNotebookInstanceInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *StartNotebookInstanceInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "StartNotebookInstanceInput"}

	if s.NotebookInstanceName == nil {
		invalidParams.Add(aws.NewErrParamRequired("NotebookInstanceName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/StartNotebookInstanceOutput
type StartNotebookInstanceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s StartNotebookInstanceOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StartNotebookInstanceOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s StartNotebookInstanceOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/StopNotebookInstanceInput
type StopNotebookInstanceInput struct {
	_ struct{} `type:"structure"`

	// The name of the notebook instance to terminate.
	//
	// NotebookInstanceName is a required field
	NotebookInstanceName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s StopNotebookInstanceInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StopNotebookInstanceInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *StopNotebookInstanceInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "StopNotebookInstanceInput"}

	if s.NotebookInstanceName == nil {
		invalidParams.Add(aws.NewErrParamRequired("NotebookInstanceName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/StopNotebookInstanceOutput
type StopNotebookInstanceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s StopNotebookInstanceOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StopNotebookInstanceOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s StopNotebookInstanceOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/StopTrainingJobRequest
type StopTrainingJobInput struct {
	_ struct{} `type:"structure"`

	// The name of the training job to stop.
	//
	// TrainingJobName is a required field
	TrainingJobName *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s StopTrainingJobInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StopTrainingJobInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *StopTrainingJobInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "StopTrainingJobInput"}

	if s.TrainingJobName == nil {
		invalidParams.Add(aws.NewErrParamRequired("TrainingJobName"))
	}
	if s.TrainingJobName != nil && len(*s.TrainingJobName) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("TrainingJobName", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/StopTrainingJobOutput
type StopTrainingJobOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s StopTrainingJobOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StopTrainingJobOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s StopTrainingJobOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Specifies how long model training can run. When model training reaches the
// limit, Amazon SageMaker ends the training job. Use this API to cap model
// training cost.
//
// To stop a job, Amazon SageMaker sends the algorithm the SIGTERM signal, which
// delays job termination for120 seconds. Algorithms might use this 120-second
// window to save the model artifacts, so the results of training is not lost.
//
// Training algorithms provided by Amazon SageMaker automatically saves the
// intermediate results of a model training job (it is best effort case, as
// model might not be ready to save as some stages, for example training just
// started). This intermediate data is a valid model artifact. You can use it
// to create a model (CreateModel).
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/StoppingCondition
type StoppingCondition struct {
	_ struct{} `type:"structure"`

	// The maximum length of time, in seconds, that the training job can run. If
	// model training does not complete during this time, Amazon SageMaker ends
	// the job. If value is not specified, default value is 1 day. Maximum value
	// is 5 days.
	MaxRuntimeInSeconds *int64 `min:"1" type:"integer"`
}

// String returns the string representation
func (s StoppingCondition) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StoppingCondition) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *StoppingCondition) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "StoppingCondition"}
	if s.MaxRuntimeInSeconds != nil && *s.MaxRuntimeInSeconds < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("MaxRuntimeInSeconds", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Describes a tag.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/Tag
type Tag struct {
	_ struct{} `type:"structure"`

	// The tag key.
	//
	// Key is a required field
	Key *string `min:"1" type:"string" required:"true"`

	// The tag value.
	//
	// Value is a required field
	Value *string `type:"string" required:"true"`
}

// String returns the string representation
func (s Tag) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s Tag) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *Tag) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "Tag"}

	if s.Key == nil {
		invalidParams.Add(aws.NewErrParamRequired("Key"))
	}
	if s.Key != nil && len(*s.Key) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Key", 1))
	}

	if s.Value == nil {
		invalidParams.Add(aws.NewErrParamRequired("Value"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Provides summary information about a training job.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/TrainingJobSummary
type TrainingJobSummary struct {
	_ struct{} `type:"structure"`

	// A timestamp that shows when the training job was created.
	//
	// CreationTime is a required field
	CreationTime *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`

	// Timestamp when the training job was last modified.
	LastModifiedTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A timestamp that shows when the training job ended. This field is set only
	// if the training job has one of the terminal statuses (Completed, Failed,
	// or Stopped).
	TrainingEndTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The Amazon Resource Name (ARN) of the training job.
	//
	// TrainingJobArn is a required field
	TrainingJobArn *string `type:"string" required:"true"`

	// The name of the training job that you want a summary for.
	//
	// TrainingJobName is a required field
	TrainingJobName *string `min:"1" type:"string" required:"true"`

	// The status of the training job.
	//
	// TrainingJobStatus is a required field
	TrainingJobStatus TrainingJobStatus `type:"string" required:"true" enum:"true"`
}

// String returns the string representation
func (s TrainingJobSummary) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s TrainingJobSummary) GoString() string {
	return s.String()
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/UpdateEndpointInput
type UpdateEndpointInput struct {
	_ struct{} `type:"structure"`

	// The name of the new endpoint configuration.
	//
	// EndpointConfigName is a required field
	EndpointConfigName *string `type:"string" required:"true"`

	// The name of the endpoint whose configuration you want to update.
	//
	// EndpointName is a required field
	EndpointName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s UpdateEndpointInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateEndpointInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateEndpointInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateEndpointInput"}

	if s.EndpointConfigName == nil {
		invalidParams.Add(aws.NewErrParamRequired("EndpointConfigName"))
	}

	if s.EndpointName == nil {
		invalidParams.Add(aws.NewErrParamRequired("EndpointName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/UpdateEndpointOutput
type UpdateEndpointOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The Amazon Resource Name (ARN) of the endpoint.
	//
	// EndpointArn is a required field
	EndpointArn *string `min:"20" type:"string" required:"true"`
}

// String returns the string representation
func (s UpdateEndpointOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateEndpointOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateEndpointOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/UpdateEndpointWeightsAndCapacitiesInput
type UpdateEndpointWeightsAndCapacitiesInput struct {
	_ struct{} `type:"structure"`

	// An object that provides new capacity and weight values for a variant.
	//
	// DesiredWeightsAndCapacities is a required field
	DesiredWeightsAndCapacities []DesiredWeightAndCapacity `min:"1" type:"list" required:"true"`

	// The name of an existing Amazon SageMaker endpoint.
	//
	// EndpointName is a required field
	EndpointName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s UpdateEndpointWeightsAndCapacitiesInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateEndpointWeightsAndCapacitiesInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateEndpointWeightsAndCapacitiesInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateEndpointWeightsAndCapacitiesInput"}

	if s.DesiredWeightsAndCapacities == nil {
		invalidParams.Add(aws.NewErrParamRequired("DesiredWeightsAndCapacities"))
	}
	if s.DesiredWeightsAndCapacities != nil && len(s.DesiredWeightsAndCapacities) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("DesiredWeightsAndCapacities", 1))
	}

	if s.EndpointName == nil {
		invalidParams.Add(aws.NewErrParamRequired("EndpointName"))
	}
	if s.DesiredWeightsAndCapacities != nil {
		for i, v := range s.DesiredWeightsAndCapacities {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "DesiredWeightsAndCapacities", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/UpdateEndpointWeightsAndCapacitiesOutput
type UpdateEndpointWeightsAndCapacitiesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The Amazon Resource Name (ARN) of the updated endpoint.
	//
	// EndpointArn is a required field
	EndpointArn *string `min:"20" type:"string" required:"true"`
}

// String returns the string representation
func (s UpdateEndpointWeightsAndCapacitiesOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateEndpointWeightsAndCapacitiesOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateEndpointWeightsAndCapacitiesOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/UpdateNotebookInstanceInput
type UpdateNotebookInstanceInput struct {
	_ struct{} `type:"structure"`

	// The Amazon ML compute instance type.
	InstanceType InstanceType `type:"string" enum:"true"`

	// The name of the notebook instance to update.
	//
	// NotebookInstanceName is a required field
	NotebookInstanceName *string `type:"string" required:"true"`

	// Amazon Resource Name (ARN) of the IAM role to associate with the instance.
	RoleArn *string `min:"20" type:"string"`
}

// String returns the string representation
func (s UpdateNotebookInstanceInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateNotebookInstanceInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateNotebookInstanceInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateNotebookInstanceInput"}

	if s.NotebookInstanceName == nil {
		invalidParams.Add(aws.NewErrParamRequired("NotebookInstanceName"))
	}
	if s.RoleArn != nil && len(*s.RoleArn) < 20 {
		invalidParams.Add(aws.NewErrParamMinLen("RoleArn", 20))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/UpdateNotebookInstanceLifecycleConfigInput
type UpdateNotebookInstanceLifecycleConfigInput struct {
	_ struct{} `type:"structure"`

	// The name of the lifecycle configuration.
	//
	// NotebookInstanceLifecycleConfigName is a required field
	NotebookInstanceLifecycleConfigName *string `type:"string" required:"true"`

	// The shell script that runs only once, when you create a notebook instance
	OnCreate []NotebookInstanceLifecycleHook `type:"list"`

	// The shell script that runs every time you start a notebook instance, including
	// when you create the notebook instance.
	OnStart []NotebookInstanceLifecycleHook `type:"list"`
}

// String returns the string representation
func (s UpdateNotebookInstanceLifecycleConfigInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateNotebookInstanceLifecycleConfigInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateNotebookInstanceLifecycleConfigInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateNotebookInstanceLifecycleConfigInput"}

	if s.NotebookInstanceLifecycleConfigName == nil {
		invalidParams.Add(aws.NewErrParamRequired("NotebookInstanceLifecycleConfigName"))
	}
	if s.OnCreate != nil {
		for i, v := range s.OnCreate {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "OnCreate", i), err.(aws.ErrInvalidParams))
			}
		}
	}
	if s.OnStart != nil {
		for i, v := range s.OnStart {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "OnStart", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/UpdateNotebookInstanceLifecycleConfigOutput
type UpdateNotebookInstanceLifecycleConfigOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s UpdateNotebookInstanceLifecycleConfigOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateNotebookInstanceLifecycleConfigOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateNotebookInstanceLifecycleConfigOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/UpdateNotebookInstanceOutput
type UpdateNotebookInstanceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s UpdateNotebookInstanceOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateNotebookInstanceOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateNotebookInstanceOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// 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 host-vpc and train-vpc.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/VpcConfig
type VpcConfig struct {
	_ struct{} `type:"structure"`

	// The VPC security group IDs, in the form sg-xxxxxxxx. Specify the security
	// groups for the VPC that is specified in the Subnets field.
	//
	// SecurityGroupIds is a required field
	SecurityGroupIds []string `min:"1" type:"list" required:"true"`

	// The ID of the subnets in the VPC to which you want to connect your training
	// job or model.
	//
	// Subnets is a required field
	Subnets []string `min:"1" type:"list" required:"true"`
}

// String returns the string representation
func (s VpcConfig) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s VpcConfig) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *VpcConfig) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "VpcConfig"}

	if s.SecurityGroupIds == nil {
		invalidParams.Add(aws.NewErrParamRequired("SecurityGroupIds"))
	}
	if s.SecurityGroupIds != nil && len(s.SecurityGroupIds) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("SecurityGroupIds", 1))
	}

	if s.Subnets == nil {
		invalidParams.Add(aws.NewErrParamRequired("Subnets"))
	}
	if s.Subnets != nil && len(s.Subnets) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Subnets", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

type CompressionType string

// Enum values for CompressionType
const (
	CompressionTypeNone CompressionType = "None"
	CompressionTypeGzip CompressionType = "Gzip"
)

func (enum CompressionType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum CompressionType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type DirectInternetAccess string

// Enum values for DirectInternetAccess
const (
	DirectInternetAccessEnabled  DirectInternetAccess = "Enabled"
	DirectInternetAccessDisabled DirectInternetAccess = "Disabled"
)

func (enum DirectInternetAccess) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DirectInternetAccess) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type EndpointConfigSortKey string

// Enum values for EndpointConfigSortKey
const (
	EndpointConfigSortKeyName         EndpointConfigSortKey = "Name"
	EndpointConfigSortKeyCreationTime EndpointConfigSortKey = "CreationTime"
)

func (enum EndpointConfigSortKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum EndpointConfigSortKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type EndpointSortKey string

// Enum values for EndpointSortKey
const (
	EndpointSortKeyName         EndpointSortKey = "Name"
	EndpointSortKeyCreationTime EndpointSortKey = "CreationTime"
	EndpointSortKeyStatus       EndpointSortKey = "Status"
)

func (enum EndpointSortKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum EndpointSortKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type EndpointStatus string

// Enum values for EndpointStatus
const (
	EndpointStatusOutOfService EndpointStatus = "OutOfService"
	EndpointStatusCreating     EndpointStatus = "Creating"
	EndpointStatusUpdating     EndpointStatus = "Updating"
	EndpointStatusRollingBack  EndpointStatus = "RollingBack"
	EndpointStatusInService    EndpointStatus = "InService"
	EndpointStatusDeleting     EndpointStatus = "Deleting"
	EndpointStatusFailed       EndpointStatus = "Failed"
)

func (enum EndpointStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum EndpointStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type InstanceType string

// Enum values for InstanceType
const (
	InstanceTypeMlT2Medium   InstanceType = "ml.t2.medium"
	InstanceTypeMlT2Large    InstanceType = "ml.t2.large"
	InstanceTypeMlT2Xlarge   InstanceType = "ml.t2.xlarge"
	InstanceTypeMlT22xlarge  InstanceType = "ml.t2.2xlarge"
	InstanceTypeMlM4Xlarge   InstanceType = "ml.m4.xlarge"
	InstanceTypeMlM42xlarge  InstanceType = "ml.m4.2xlarge"
	InstanceTypeMlM44xlarge  InstanceType = "ml.m4.4xlarge"
	InstanceTypeMlM410xlarge InstanceType = "ml.m4.10xlarge"
	InstanceTypeMlM416xlarge InstanceType = "ml.m4.16xlarge"
	InstanceTypeMlP2Xlarge   InstanceType = "ml.p2.xlarge"
	InstanceTypeMlP28xlarge  InstanceType = "ml.p2.8xlarge"
	InstanceTypeMlP216xlarge InstanceType = "ml.p2.16xlarge"
	InstanceTypeMlP32xlarge  InstanceType = "ml.p3.2xlarge"
	InstanceTypeMlP38xlarge  InstanceType = "ml.p3.8xlarge"
	InstanceTypeMlP316xlarge InstanceType = "ml.p3.16xlarge"
)

func (enum InstanceType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InstanceType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ModelSortKey string

// Enum values for ModelSortKey
const (
	ModelSortKeyName         ModelSortKey = "Name"
	ModelSortKeyCreationTime ModelSortKey = "CreationTime"
)

func (enum ModelSortKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ModelSortKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type NotebookInstanceLifecycleConfigSortKey string

// Enum values for NotebookInstanceLifecycleConfigSortKey
const (
	NotebookInstanceLifecycleConfigSortKeyName             NotebookInstanceLifecycleConfigSortKey = "Name"
	NotebookInstanceLifecycleConfigSortKeyCreationTime     NotebookInstanceLifecycleConfigSortKey = "CreationTime"
	NotebookInstanceLifecycleConfigSortKeyLastModifiedTime NotebookInstanceLifecycleConfigSortKey = "LastModifiedTime"
)

func (enum NotebookInstanceLifecycleConfigSortKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NotebookInstanceLifecycleConfigSortKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type NotebookInstanceLifecycleConfigSortOrder string

// Enum values for NotebookInstanceLifecycleConfigSortOrder
const (
	NotebookInstanceLifecycleConfigSortOrderAscending  NotebookInstanceLifecycleConfigSortOrder = "Ascending"
	NotebookInstanceLifecycleConfigSortOrderDescending NotebookInstanceLifecycleConfigSortOrder = "Descending"
)

func (enum NotebookInstanceLifecycleConfigSortOrder) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NotebookInstanceLifecycleConfigSortOrder) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type NotebookInstanceSortKey string

// Enum values for NotebookInstanceSortKey
const (
	NotebookInstanceSortKeyName         NotebookInstanceSortKey = "Name"
	NotebookInstanceSortKeyCreationTime NotebookInstanceSortKey = "CreationTime"
	NotebookInstanceSortKeyStatus       NotebookInstanceSortKey = "Status"
)

func (enum NotebookInstanceSortKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NotebookInstanceSortKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type NotebookInstanceSortOrder string

// Enum values for NotebookInstanceSortOrder
const (
	NotebookInstanceSortOrderAscending  NotebookInstanceSortOrder = "Ascending"
	NotebookInstanceSortOrderDescending NotebookInstanceSortOrder = "Descending"
)

func (enum NotebookInstanceSortOrder) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NotebookInstanceSortOrder) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type NotebookInstanceStatus string

// Enum values for NotebookInstanceStatus
const (
	NotebookInstanceStatusPending   NotebookInstanceStatus = "Pending"
	NotebookInstanceStatusInService NotebookInstanceStatus = "InService"
	NotebookInstanceStatusStopping  NotebookInstanceStatus = "Stopping"
	NotebookInstanceStatusStopped   NotebookInstanceStatus = "Stopped"
	NotebookInstanceStatusFailed    NotebookInstanceStatus = "Failed"
	NotebookInstanceStatusDeleting  NotebookInstanceStatus = "Deleting"
)

func (enum NotebookInstanceStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NotebookInstanceStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type OrderKey string

// Enum values for OrderKey
const (
	OrderKeyAscending  OrderKey = "Ascending"
	OrderKeyDescending OrderKey = "Descending"
)

func (enum OrderKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum OrderKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ProductionVariantInstanceType string

// Enum values for ProductionVariantInstanceType
const (
	ProductionVariantInstanceTypeMlT2Medium   ProductionVariantInstanceType = "ml.t2.medium"
	ProductionVariantInstanceTypeMlT2Large    ProductionVariantInstanceType = "ml.t2.large"
	ProductionVariantInstanceTypeMlT2Xlarge   ProductionVariantInstanceType = "ml.t2.xlarge"
	ProductionVariantInstanceTypeMlT22xlarge  ProductionVariantInstanceType = "ml.t2.2xlarge"
	ProductionVariantInstanceTypeMlM4Xlarge   ProductionVariantInstanceType = "ml.m4.xlarge"
	ProductionVariantInstanceTypeMlM42xlarge  ProductionVariantInstanceType = "ml.m4.2xlarge"
	ProductionVariantInstanceTypeMlM44xlarge  ProductionVariantInstanceType = "ml.m4.4xlarge"
	ProductionVariantInstanceTypeMlM410xlarge ProductionVariantInstanceType = "ml.m4.10xlarge"
	ProductionVariantInstanceTypeMlM416xlarge ProductionVariantInstanceType = "ml.m4.16xlarge"
	ProductionVariantInstanceTypeMlM5Large    ProductionVariantInstanceType = "ml.m5.large"
	ProductionVariantInstanceTypeMlM5Xlarge   ProductionVariantInstanceType = "ml.m5.xlarge"
	ProductionVariantInstanceTypeMlM52xlarge  ProductionVariantInstanceType = "ml.m5.2xlarge"
	ProductionVariantInstanceTypeMlM54xlarge  ProductionVariantInstanceType = "ml.m5.4xlarge"
	ProductionVariantInstanceTypeMlM512xlarge ProductionVariantInstanceType = "ml.m5.12xlarge"
	ProductionVariantInstanceTypeMlM524xlarge ProductionVariantInstanceType = "ml.m5.24xlarge"
	ProductionVariantInstanceTypeMlC4Large    ProductionVariantInstanceType = "ml.c4.large"
	ProductionVariantInstanceTypeMlC4Xlarge   ProductionVariantInstanceType = "ml.c4.xlarge"
	ProductionVariantInstanceTypeMlC42xlarge  ProductionVariantInstanceType = "ml.c4.2xlarge"
	ProductionVariantInstanceTypeMlC44xlarge  ProductionVariantInstanceType = "ml.c4.4xlarge"
	ProductionVariantInstanceTypeMlC48xlarge  ProductionVariantInstanceType = "ml.c4.8xlarge"
	ProductionVariantInstanceTypeMlP2Xlarge   ProductionVariantInstanceType = "ml.p2.xlarge"
	ProductionVariantInstanceTypeMlP28xlarge  ProductionVariantInstanceType = "ml.p2.8xlarge"
	ProductionVariantInstanceTypeMlP216xlarge ProductionVariantInstanceType = "ml.p2.16xlarge"
	ProductionVariantInstanceTypeMlP32xlarge  ProductionVariantInstanceType = "ml.p3.2xlarge"
	ProductionVariantInstanceTypeMlP38xlarge  ProductionVariantInstanceType = "ml.p3.8xlarge"
	ProductionVariantInstanceTypeMlP316xlarge ProductionVariantInstanceType = "ml.p3.16xlarge"
	ProductionVariantInstanceTypeMlC5Large    ProductionVariantInstanceType = "ml.c5.large"
	ProductionVariantInstanceTypeMlC5Xlarge   ProductionVariantInstanceType = "ml.c5.xlarge"
	ProductionVariantInstanceTypeMlC52xlarge  ProductionVariantInstanceType = "ml.c5.2xlarge"
	ProductionVariantInstanceTypeMlC54xlarge  ProductionVariantInstanceType = "ml.c5.4xlarge"
	ProductionVariantInstanceTypeMlC59xlarge  ProductionVariantInstanceType = "ml.c5.9xlarge"
	ProductionVariantInstanceTypeMlC518xlarge ProductionVariantInstanceType = "ml.c5.18xlarge"
)

func (enum ProductionVariantInstanceType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ProductionVariantInstanceType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type RecordWrapper string

// Enum values for RecordWrapper
const (
	RecordWrapperNone     RecordWrapper = "None"
	RecordWrapperRecordIo RecordWrapper = "RecordIO"
)

func (enum RecordWrapper) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum RecordWrapper) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type S3DataDistribution string

// Enum values for S3DataDistribution
const (
	S3DataDistributionFullyReplicated S3DataDistribution = "FullyReplicated"
	S3DataDistributionShardedByS3key  S3DataDistribution = "ShardedByS3Key"
)

func (enum S3DataDistribution) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum S3DataDistribution) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type S3DataType string

// Enum values for S3DataType
const (
	S3DataTypeManifestFile S3DataType = "ManifestFile"
	S3DataTypeS3prefix     S3DataType = "S3Prefix"
)

func (enum S3DataType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum S3DataType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SecondaryStatus string

// Enum values for SecondaryStatus
const (
	SecondaryStatusStarting           SecondaryStatus = "Starting"
	SecondaryStatusDownloading        SecondaryStatus = "Downloading"
	SecondaryStatusTraining           SecondaryStatus = "Training"
	SecondaryStatusUploading          SecondaryStatus = "Uploading"
	SecondaryStatusStopping           SecondaryStatus = "Stopping"
	SecondaryStatusStopped            SecondaryStatus = "Stopped"
	SecondaryStatusMaxRuntimeExceeded SecondaryStatus = "MaxRuntimeExceeded"
	SecondaryStatusCompleted          SecondaryStatus = "Completed"
	SecondaryStatusFailed             SecondaryStatus = "Failed"
)

func (enum SecondaryStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SecondaryStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SortBy string

// Enum values for SortBy
const (
	SortByName         SortBy = "Name"
	SortByCreationTime SortBy = "CreationTime"
	SortByStatus       SortBy = "Status"
)

func (enum SortBy) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SortBy) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SortOrder string

// Enum values for SortOrder
const (
	SortOrderAscending  SortOrder = "Ascending"
	SortOrderDescending SortOrder = "Descending"
)

func (enum SortOrder) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SortOrder) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type TrainingInputMode string

// Enum values for TrainingInputMode
const (
	TrainingInputModePipe TrainingInputMode = "Pipe"
	TrainingInputModeFile TrainingInputMode = "File"
)

func (enum TrainingInputMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum TrainingInputMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type TrainingInstanceType string

// Enum values for TrainingInstanceType
const (
	TrainingInstanceTypeMlM4Xlarge   TrainingInstanceType = "ml.m4.xlarge"
	TrainingInstanceTypeMlM42xlarge  TrainingInstanceType = "ml.m4.2xlarge"
	TrainingInstanceTypeMlM44xlarge  TrainingInstanceType = "ml.m4.4xlarge"
	TrainingInstanceTypeMlM410xlarge TrainingInstanceType = "ml.m4.10xlarge"
	TrainingInstanceTypeMlM416xlarge TrainingInstanceType = "ml.m4.16xlarge"
	TrainingInstanceTypeMlM5Large    TrainingInstanceType = "ml.m5.large"
	TrainingInstanceTypeMlM5Xlarge   TrainingInstanceType = "ml.m5.xlarge"
	TrainingInstanceTypeMlM52xlarge  TrainingInstanceType = "ml.m5.2xlarge"
	TrainingInstanceTypeMlM54xlarge  TrainingInstanceType = "ml.m5.4xlarge"
	TrainingInstanceTypeMlM512xlarge TrainingInstanceType = "ml.m5.12xlarge"
	TrainingInstanceTypeMlM524xlarge TrainingInstanceType = "ml.m5.24xlarge"
	TrainingInstanceTypeMlC4Xlarge   TrainingInstanceType = "ml.c4.xlarge"
	TrainingInstanceTypeMlC42xlarge  TrainingInstanceType = "ml.c4.2xlarge"
	TrainingInstanceTypeMlC44xlarge  TrainingInstanceType = "ml.c4.4xlarge"
	TrainingInstanceTypeMlC48xlarge  TrainingInstanceType = "ml.c4.8xlarge"
	TrainingInstanceTypeMlP2Xlarge   TrainingInstanceType = "ml.p2.xlarge"
	TrainingInstanceTypeMlP28xlarge  TrainingInstanceType = "ml.p2.8xlarge"
	TrainingInstanceTypeMlP216xlarge TrainingInstanceType = "ml.p2.16xlarge"
	TrainingInstanceTypeMlP32xlarge  TrainingInstanceType = "ml.p3.2xlarge"
	TrainingInstanceTypeMlP38xlarge  TrainingInstanceType = "ml.p3.8xlarge"
	TrainingInstanceTypeMlP316xlarge TrainingInstanceType = "ml.p3.16xlarge"
	TrainingInstanceTypeMlC5Xlarge   TrainingInstanceType = "ml.c5.xlarge"
	TrainingInstanceTypeMlC52xlarge  TrainingInstanceType = "ml.c5.2xlarge"
	TrainingInstanceTypeMlC54xlarge  TrainingInstanceType = "ml.c5.4xlarge"
	TrainingInstanceTypeMlC59xlarge  TrainingInstanceType = "ml.c5.9xlarge"
	TrainingInstanceTypeMlC518xlarge TrainingInstanceType = "ml.c5.18xlarge"
)

func (enum TrainingInstanceType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum TrainingInstanceType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type TrainingJobStatus string

// Enum values for TrainingJobStatus
const (
	TrainingJobStatusInProgress TrainingJobStatus = "InProgress"
	TrainingJobStatusCompleted  TrainingJobStatus = "Completed"
	TrainingJobStatusFailed     TrainingJobStatus = "Failed"
	TrainingJobStatusStopping   TrainingJobStatus = "Stopping"
	TrainingJobStatusStopped    TrainingJobStatus = "Stopped"
)

func (enum TrainingJobStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum TrainingJobStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}