text:
#pragma once
#include <aws/sagemaker/SageMaker_EXPORTS.h>
#include <aws/sagemaker/SageMakerRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/sagemaker/model/AlgorithmSpecification.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/sagemaker/model/OutputDataConfig.h>
#include <aws/sagemaker/model/ResourceConfig.h>
#include <aws/sagemaker/model/VpcConfig.h>
#include <aws/sagemaker/model/StoppingCondition.h>
#include <aws/sagemaker/model/CheckpointConfig.h>
#include <aws/sagemaker/model/DebugHookConfig.h>
#include <aws/sagemaker/model/TensorBoardOutputConfig.h>
#include <aws/sagemaker/model/ExperimentConfig.h>
#include <aws/sagemaker/model/ProfilerConfig.h>
#include <aws/sagemaker/model/RetryStrategy.h>
#include <aws/sagemaker/model/Channel.h>
#include <aws/sagemaker/model/Tag.h>
#include <aws/sagemaker/model/DebugRuleConfiguration.h>
#include <aws/sagemaker/model/ProfilerRuleConfiguration.h>
#include <utility>

namespace Aws
{
namespace SageMaker
{
namespace Model
{

  /**
   */
  class AWS_SAGEMAKER_API CreateTrainingJobRequest : public SageMakerRequest
  {
  public:
    CreateTrainingJobRequest();

    // Service request name is the Operation name which will send this request out,
    // each operation should has unique request name, so that we can get operation's name from this request.
    // Note: this is not true for response, multiple operations may have the same response name,
    // so we can not get operation's name from response.
    inline virtual const char* GetServiceRequestName() const override { return "CreateTrainingJob"; }

    Aws::String SerializePayload() const override;

    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;

    /**
     *
The name of the training job. The name must be unique within an Amazon Web
     * Services Region in an Amazon Web Services account.

     */
    inline const Aws::String& GetTrainingJobName() const{ return m_trainingJobName; }

    /**
     *
The name of the training job. The name must be unique within an Amazon Web
     * Services Region in an Amazon Web Services account.

     */
    inline bool TrainingJobNameHasBeenSet() const { return m_trainingJobNameHasBeenSet; }

    /**
     *
The name of the training job. The name must be unique within an Amazon Web
     * Services Region in an Amazon Web Services account.

     */
    inline void SetTrainingJobName(const Aws::String& value) { m_trainingJobNameHasBeenSet = true; m_trainingJobName = value; }

    /**
     *
The name of the training job. The name must be unique within an Amazon Web
     * Services Region in an Amazon Web Services account.

     */
    inline void SetTrainingJobName(Aws::String&& value) { m_trainingJobNameHasBeenSet = true; m_trainingJobName = std::move(value); }

    /**
     *
The name of the training job. The name must be unique within an Amazon Web
     * Services Region in an Amazon Web Services account.

     */
    inline void SetTrainingJobName(const char* value) { m_trainingJobNameHasBeenSet = true; m_trainingJobName.assign(value); }

    /**
     *
The name of the training job. The name must be unique within an Amazon Web
     * Services Region in an Amazon Web Services account.

     */
    inline CreateTrainingJobRequest& WithTrainingJobName(const Aws::String& value) { SetTrainingJobName(value); return *this;}

    /**
     *
The name of the training job. The name must be unique within an Amazon Web
     * Services Region in an Amazon Web Services account.

     */
    inline CreateTrainingJobRequest& WithTrainingJobName(Aws::String&& value) { SetTrainingJobName(std::move(value)); return *this;}

    /**
     *
The name of the training job. The name must be unique within an Amazon Web
     * Services Region in an Amazon Web Services account.

     */
    inline CreateTrainingJobRequest& WithTrainingJobName(const char* value) { SetTrainingJobName(value); return *this;}

    /**
     *
Algorithm-specific parameters that influence the quality of the model. You
     * set hyperparameters before you start the learning process. For a list of
     * hyperparameters for each training algorithm provided by SageMaker, see Algorithms.
     *

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.

     */
    inline const Aws::Map<Aws::String, Aws::String>& GetHyperParameters() const{ return m_hyperParameters; }

    /**
     *
Algorithm-specific parameters that influence the quality of the model. You
     * set hyperparameters before you start the learning process. For a list of
     * hyperparameters for each training algorithm provided by SageMaker, see Algorithms.
     *

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.

     */
    inline bool HyperParametersHasBeenSet() const { return m_hyperParametersHasBeenSet; }

    /**
     *
Algorithm-specific parameters that influence the quality of the model. You
     * set hyperparameters before you start the learning process. For a list of
     * hyperparameters for each training algorithm provided by SageMaker, see Algorithms.
     *

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.

     */
    inline void SetHyperParameters(const Aws::Map<Aws::String, Aws::String>& value) { m_hyperParametersHasBeenSet = true; m_hyperParameters = value; }

    /**
     *
Algorithm-specific parameters that influence the quality of the model. You
     * set hyperparameters before you start the learning process. For a list of
     * hyperparameters for each training algorithm provided by SageMaker, see Algorithms.
     *

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.

     */
    inline void SetHyperParameters(Aws::Map<Aws::String, Aws::String>&& value) { m_hyperParametersHasBeenSet = true; m_hyperParameters = std::move(value); }

    /**
     *
Algorithm-specific parameters that influence the quality of the model. You
     * set hyperparameters before you start the learning process. For a list of
     * hyperparameters for each training algorithm provided by SageMaker, see Algorithms.
     *

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.

     */
    inline CreateTrainingJobRequest& WithHyperParameters(const Aws::Map<Aws::String, Aws::String>& value) { SetHyperParameters(value); return *this;}

    /**
     *
Algorithm-specific parameters that influence the quality of the model. You
     * set hyperparameters before you start the learning process. For a list of
     * hyperparameters for each training algorithm provided by SageMaker, see Algorithms.
     *

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.

     */
    inline CreateTrainingJobRequest& WithHyperParameters(Aws::Map<Aws::String, Aws::String>&& value) { SetHyperParameters(std::move(value)); return *this;}

    /**
     *
Algorithm-specific parameters that influence the quality of the model. You
     * set hyperparameters before you start the learning process. For a list of
     * hyperparameters for each training algorithm provided by SageMaker, see Algorithms.
     *

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.

     */
    inline CreateTrainingJobRequest& AddHyperParameters(const Aws::String& key, const Aws::String& value) { m_hyperParametersHasBeenSet = true; m_hyperParameters.emplace(key, value); return *this; }

    /**
     *
Algorithm-specific parameters that influence the quality of the model. You
     * set hyperparameters before you start the learning process. For a list of
     * hyperparameters for each training algorithm provided by SageMaker, see Algorithms.
     *

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.

     */
    inline CreateTrainingJobRequest& AddHyperParameters(Aws::String&& key, const Aws::String& value) { m_hyperParametersHasBeenSet = true; m_hyperParameters.emplace(std::move(key), value); return *this; }

    /**
     *
Algorithm-specific parameters that influence the quality of the model. You
     * set hyperparameters before you start the learning process. For a list of
     * hyperparameters for each training algorithm provided by SageMaker, see Algorithms.
     *

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.

     */
    inline CreateTrainingJobRequest& AddHyperParameters(const Aws::String& key, Aws::String&& value) { m_hyperParametersHasBeenSet = true; m_hyperParameters.emplace(key, std::move(value)); return *this; }

    /**
     *
Algorithm-specific parameters that influence the quality of the model. You
     * set hyperparameters before you start the learning process. For a list of
     * hyperparameters for each training algorithm provided by SageMaker, see Algorithms.
     *

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.

     */
    inline CreateTrainingJobRequest& AddHyperParameters(Aws::String&& key, Aws::String&& value) { m_hyperParametersHasBeenSet = true; m_hyperParameters.emplace(std::move(key), std::move(value)); return *this; }

    /**
     *
Algorithm-specific parameters that influence the quality of the model. You
     * set hyperparameters before you start the learning process. For a list of
     * hyperparameters for each training algorithm provided by SageMaker, see Algorithms.
     *

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.

     */
    inline CreateTrainingJobRequest& AddHyperParameters(const char* key, Aws::String&& value) { m_hyperParametersHasBeenSet = true; m_hyperParameters.emplace(key, std::move(value)); return *this; }

    /**
     *
Algorithm-specific parameters that influence the quality of the model. You
     * set hyperparameters before you start the learning process. For a list of
     * hyperparameters for each training algorithm provided by SageMaker, see Algorithms.
     *

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.

     */
    inline CreateTrainingJobRequest& AddHyperParameters(Aws::String&& key, const char* value) { m_hyperParametersHasBeenSet = true; m_hyperParameters.emplace(std::move(key), value); return *this; }

    /**
     *
Algorithm-specific parameters that influence the quality of the model. You
     * set hyperparameters before you start the learning process. For a list of
     * hyperparameters for each training algorithm provided by SageMaker, see Algorithms.
     *

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.

     */
    inline CreateTrainingJobRequest& AddHyperParameters(const char* key, const char* value) { m_hyperParametersHasBeenSet = true; m_hyperParameters.emplace(key, value); return *this; }

    /**
     *
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 SageMaker, see Algorithms.
     * For information about providing your own algorithms, see Using
     * Your Own Algorithms with Amazon SageMaker.

     */
    inline const AlgorithmSpecification& GetAlgorithmSpecification() const{ return m_algorithmSpecification; }

    /**
     *
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 SageMaker, see Algorithms.
     * For information about providing your own algorithms, see Using
     * Your Own Algorithms with Amazon SageMaker.

     */
    inline bool AlgorithmSpecificationHasBeenSet() const { return m_algorithmSpecificationHasBeenSet; }

    /**
     *
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 SageMaker, see Algorithms.
     * For information about providing your own algorithms, see Using
     * Your Own Algorithms with Amazon SageMaker.

     */
    inline void SetAlgorithmSpecification(const AlgorithmSpecification& value) { m_algorithmSpecificationHasBeenSet = true; m_algorithmSpecification = value; }

    /**
     *
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 SageMaker, see Algorithms.
     * For information about providing your own algorithms, see Using
     * Your Own Algorithms with Amazon SageMaker.

     */
    inline void SetAlgorithmSpecification(AlgorithmSpecification&& value) { m_algorithmSpecificationHasBeenSet = true; m_algorithmSpecification = std::move(value); }

    /**
     *
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 SageMaker, see Algorithms.
     * For information about providing your own algorithms, see Using
     * Your Own Algorithms with Amazon SageMaker.

     */
    inline CreateTrainingJobRequest& WithAlgorithmSpecification(const AlgorithmSpecification& value) { SetAlgorithmSpecification(value); return *this;}

    /**
     *
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 SageMaker, see Algorithms.
     * For information about providing your own algorithms, see Using
     * Your Own Algorithms with Amazon SageMaker.

     */
    inline CreateTrainingJobRequest& WithAlgorithmSpecification(AlgorithmSpecification&& value) { SetAlgorithmSpecification(std::move(value)); return *this;}

    /**
     *
The Amazon Resource Name (ARN) of an IAM role that SageMaker can assume to
     * perform tasks on your behalf.

During model training, 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 SageMaker
     * Roles.

To be able to pass this role to SageMaker, the caller
     * of this API must have the iam:PassRole permission.

     */
    inline const Aws::String& GetRoleArn() const{ return m_roleArn; }

    /**
     *
The Amazon Resource Name (ARN) of an IAM role that SageMaker can assume to
     * perform tasks on your behalf.

During model training, 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 SageMaker
     * Roles.

To be able to pass this role to SageMaker, the caller
     * of this API must have the iam:PassRole permission.

     */
    inline bool RoleArnHasBeenSet() const { return m_roleArnHasBeenSet; }

    /**
     *
The Amazon Resource Name (ARN) of an IAM role that SageMaker can assume to
     * perform tasks on your behalf.

During model training, 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 SageMaker
     * Roles.

To be able to pass this role to SageMaker, the caller
     * of this API must have the iam:PassRole permission.

     */
    inline void SetRoleArn(const Aws::String& value) { m_roleArnHasBeenSet = true; m_roleArn = value; }

    /**
     *
The Amazon Resource Name (ARN) of an IAM role that SageMaker can assume to
     * perform tasks on your behalf.

During model training, 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 SageMaker
     * Roles.

To be able to pass this role to SageMaker, the caller
     * of this API must have the iam:PassRole permission.

     */
    inline void SetRoleArn(Aws::String&& value) { m_roleArnHasBeenSet = true; m_roleArn = std::move(value); }

    /**
     *
The Amazon Resource Name (ARN) of an IAM role that SageMaker can assume to
     * perform tasks on your behalf.

During model training, 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 SageMaker
     * Roles.

To be able to pass this role to SageMaker, the caller
     * of this API must have the iam:PassRole permission.

     */
    inline void SetRoleArn(const char* value) { m_roleArnHasBeenSet = true; m_roleArn.assign(value); }

    /**
     *
The Amazon Resource Name (ARN) of an IAM role that SageMaker can assume to
     * perform tasks on your behalf.

During model training, 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 SageMaker
     * Roles.

To be able to pass this role to SageMaker, the caller
     * of this API must have the iam:PassRole permission.

     */
    inline CreateTrainingJobRequest& WithRoleArn(const Aws::String& value) { SetRoleArn(value); return *this;}

    /**
     *
The Amazon Resource Name (ARN) of an IAM role that SageMaker can assume to
     * perform tasks on your behalf.

During model training, 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 SageMaker
     * Roles.

To be able to pass this role to SageMaker, the caller
     * of this API must have the iam:PassRole permission.

     */
    inline CreateTrainingJobRequest& WithRoleArn(Aws::String&& value) { SetRoleArn(std::move(value)); return *this;}

    /**
     *
The Amazon Resource Name (ARN) of an IAM role that SageMaker can assume to
     * perform tasks on your behalf.

During model training, 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 SageMaker
     * Roles.

To be able to pass this role to SageMaker, the caller
     * of this API must have the iam:PassRole permission.

     */
    inline CreateTrainingJobRequest& WithRoleArn(const char* value) { SetRoleArn(value); return *this;}

    /**
     *
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, EFS, or FSx location where the input data is stored. It also provides
     * information about the stored data: the MIME type, compression method, and
     * whether the data is wrapped in RecordIO format.

Depending on the input
     * mode that the algorithm supports, SageMaker either copies input data files from
     * an S3 bucket to a local directory in the Docker container, or makes it available
     * as input streams. For example, if you specify an EFS location, input data files
     * are available as input streams. They do not need to be downloaded.

     */
    inline const Aws::Vector<Channel>& GetInputDataConfig() const{ return m_inputDataConfig; }

    /**
     *
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, EFS, or FSx location where the input data is stored. It also provides
     * information about the stored data: the MIME type, compression method, and
     * whether the data is wrapped in RecordIO format.

Depending on the input
     * mode that the algorithm supports, SageMaker either copies input data files from
     * an S3 bucket to a local directory in the Docker container, or makes it available
     * as input streams. For example, if you specify an EFS location, input data files
     * are available as input streams. They do not need to be downloaded.

     */
    inline bool InputDataConfigHasBeenSet() const { return m_inputDataConfigHasBeenSet; }

    /**
     *
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, EFS, or FSx location where the input data is stored. It also provides
     * information about the stored data: the MIME type, compression method, and
     * whether the data is wrapped in RecordIO format.

Depending on the input
     * mode that the algorithm supports, SageMaker either copies input data files from
     * an S3 bucket to a local directory in the Docker container, or makes it available
     * as input streams. For example, if you specify an EFS location, input data files
     * are available as input streams. They do not need to be downloaded.

     */
    inline void SetInputDataConfig(const Aws::Vector<Channel>& value) { m_inputDataConfigHasBeenSet = true; m_inputDataConfig = value; }

    /**
     *
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, EFS, or FSx location where the input data is stored. It also provides
     * information about the stored data: the MIME type, compression method, and
     * whether the data is wrapped in RecordIO format.

Depending on the input
     * mode that the algorithm supports, SageMaker either copies input data files from
     * an S3 bucket to a local directory in the Docker container, or makes it available
     * as input streams. For example, if you specify an EFS location, input data files
     * are available as input streams. They do not need to be downloaded.

     */
    inline void SetInputDataConfig(Aws::Vector<Channel>&& value) { m_inputDataConfigHasBeenSet = true; m_inputDataConfig = std::move(value); }

    /**
     *
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, EFS, or FSx location where the input data is stored. It also provides
     * information about the stored data: the MIME type, compression method, and
     * whether the data is wrapped in RecordIO format.

Depending on the input
     * mode that the algorithm supports, SageMaker either copies input data files from
     * an S3 bucket to a local directory in the Docker container, or makes it available
     * as input streams. For example, if you specify an EFS location, input data files
     * are available as input streams. They do not need to be downloaded.

     */
    inline CreateTrainingJobRequest& WithInputDataConfig(const Aws::Vector<Channel>& value) { SetInputDataConfig(value); return *this;}

    /**
     *
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, EFS, or FSx location where the input data is stored. It also provides
     * information about the stored data: the MIME type, compression method, and
     * whether the data is wrapped in RecordIO format.

Depending on the input
     * mode that the algorithm supports, SageMaker either copies input data files from
     * an S3 bucket to a local directory in the Docker container, or makes it available
     * as input streams. For example, if you specify an EFS location, input data files
     * are available as input streams. They do not need to be downloaded.

     */
    inline CreateTrainingJobRequest& WithInputDataConfig(Aws::Vector<Channel>&& value) { SetInputDataConfig(std::move(value)); return *this;}

    /**
     *
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, EFS, or FSx location where the input data is stored. It also provides
     * information about the stored data: the MIME type, compression method, and
     * whether the data is wrapped in RecordIO format.

Depending on the input
     * mode that the algorithm supports, SageMaker either copies input data files from
     * an S3 bucket to a local directory in the Docker container, or makes it available
     * as input streams. For example, if you specify an EFS location, input data files
     * are available as input streams. They do not need to be downloaded.

     */
    inline CreateTrainingJobRequest& AddInputDataConfig(const Channel& value) { m_inputDataConfigHasBeenSet = true; m_inputDataConfig.push_back(value); return *this; }

    /**
     *
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, EFS, or FSx location where the input data is stored. It also provides
     * information about the stored data: the MIME type, compression method, and
     * whether the data is wrapped in RecordIO format.

Depending on the input
     * mode that the algorithm supports, SageMaker either copies input data files from
     * an S3 bucket to a local directory in the Docker container, or makes it available
     * as input streams. For example, if you specify an EFS location, input data files
     * are available as input streams. They do not need to be downloaded.

     */
    inline CreateTrainingJobRequest& AddInputDataConfig(Channel&& value) { m_inputDataConfigHasBeenSet = true; m_inputDataConfig.push_back(std::move(value)); return *this; }

    /**
     *
Specifies the path to the S3 location where you want to store model
     * artifacts. SageMaker creates subfolders for the artifacts.

     */
    inline const OutputDataConfig& GetOutputDataConfig() const{ return m_outputDataConfig; }

    /**
     *
Specifies the path to the S3 location where you want to store model
     * artifacts. SageMaker creates subfolders for the artifacts.

     */
    inline bool OutputDataConfigHasBeenSet() const { return m_outputDataConfigHasBeenSet; }

    /**
     *
Specifies the path to the S3 location where you want to store model
     * artifacts. SageMaker creates subfolders for the artifacts.

     */
    inline void SetOutputDataConfig(const OutputDataConfig& value) { m_outputDataConfigHasBeenSet = true; m_outputDataConfig = value; }

    /**
     *
Specifies the path to the S3 location where you want to store model
     * artifacts. SageMaker creates subfolders for the artifacts.

     */
    inline void SetOutputDataConfig(OutputDataConfig&& value) { m_outputDataConfigHasBeenSet = true; m_outputDataConfig = std::move(value); }

    /**
     *
Specifies the path to the S3 location where you want to store model
     * artifacts. SageMaker creates subfolders for the artifacts.

     */
    inline CreateTrainingJobRequest& WithOutputDataConfig(const OutputDataConfig& value) { SetOutputDataConfig(value); return *this;}

    /**
     *
Specifies the path to the S3 location where you want to store model
     * artifacts. SageMaker creates subfolders for the artifacts.

     */
    inline CreateTrainingJobRequest& WithOutputDataConfig(OutputDataConfig&& value) { SetOutputDataConfig(std::move(value)); return *this;}

    /**
     *
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 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.

     */
    inline const ResourceConfig& GetResourceConfig() const{ return m_resourceConfig; }

    /**
     *
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 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.

     */
    inline bool ResourceConfigHasBeenSet() const { return m_resourceConfigHasBeenSet; }

    /**
     *
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 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.

     */
    inline void SetResourceConfig(const ResourceConfig& value) { m_resourceConfigHasBeenSet = true; m_resourceConfig = value; }

    /**
     *
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 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.

     */
    inline void SetResourceConfig(ResourceConfig&& value) { m_resourceConfigHasBeenSet = true; m_resourceConfig = std::move(value); }

    /**
     *
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 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.

     */
    inline CreateTrainingJobRequest& WithResourceConfig(const ResourceConfig& value) { SetResourceConfig(value); return *this;}

    /**
     *
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 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.

     */
    inline CreateTrainingJobRequest& WithResourceConfig(ResourceConfig&& value) { SetResourceConfig(std::move(value)); return *this;}

    /**
     *
A VpcConfig 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 Protect
     * Training Jobs by Using an Amazon Virtual Private Cloud.

     */
    inline const VpcConfig& GetVpcConfig() const{ return m_vpcConfig; }

    /**
     *
A VpcConfig 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 Protect
     * Training Jobs by Using an Amazon Virtual Private Cloud.

     */
    inline bool VpcConfigHasBeenSet() const { return m_vpcConfigHasBeenSet; }

    /**
     *
A VpcConfig 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 Protect
     * Training Jobs by Using an Amazon Virtual Private Cloud.

     */
    inline void SetVpcConfig(const VpcConfig& value) { m_vpcConfigHasBeenSet = true; m_vpcConfig = value; }

    /**
     *
A VpcConfig 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 Protect
     * Training Jobs by Using an Amazon Virtual Private Cloud.

     */
    inline void SetVpcConfig(VpcConfig&& value) { m_vpcConfigHasBeenSet = true; m_vpcConfig = std::move(value); }

    /**
     *
A VpcConfig 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 Protect
     * Training Jobs by Using an Amazon Virtual Private Cloud.

     */
    inline CreateTrainingJobRequest& WithVpcConfig(const VpcConfig& value) { SetVpcConfig(value); return *this;}

    /**
     *
A VpcConfig 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 Protect
     * Training Jobs by Using an Amazon Virtual Private Cloud.

     */
    inline CreateTrainingJobRequest& WithVpcConfig(VpcConfig&& value) { SetVpcConfig(std::move(value)); return *this;}

    /**
     *
Specifies a limit to how long a model training job can run. It also specifies
     * how long a managed Spot training job has to complete. When the job reaches the
     * time limit, SageMaker ends the training job. Use this API to cap model training
     * costs.

To stop a job, SageMaker sends the algorithm the
     * SIGTERM signal, which delays job termination for 120 seconds.
     * Algorithms can use this 120-second window to save the model artifacts, so the
     * results of training are not lost.

     */
    inline const StoppingCondition& GetStoppingCondition() const{ return m_stoppingCondition; }

    /**
     *
Specifies a limit to how long a model training job can run. It also specifies
     * how long a managed Spot training job has to complete. When the job reaches the
     * time limit, SageMaker ends the training job. Use this API to cap model training
     * costs.

To stop a job, SageMaker sends the algorithm the
     * SIGTERM signal, which delays job termination for 120 seconds.
     * Algorithms can use this 120-second window to save the model artifacts, so the
     * results of training are not lost.

     */
    inline bool StoppingConditionHasBeenSet() const { return m_stoppingConditionHasBeenSet; }

    /**
     *
Specifies a limit to how long a model training job can run. It also specifies
     * how long a managed Spot training job has to complete. When the job reaches the
     * time limit, SageMaker ends the training job. Use this API to cap model training
     * costs.

To stop a job, SageMaker sends the algorithm the
     * SIGTERM signal, which delays job termination for 120 seconds.
     * Algorithms can use this 120-second window to save the model artifacts, so the
     * results of training are not lost.

     */
    inline void SetStoppingCondition(const StoppingCondition& value) { m_stoppingConditionHasBeenSet = true; m_stoppingCondition = value; }

    /**
     *
Specifies a limit to how long a model training job can run. It also specifies
     * how long a managed Spot training job has to complete. When the job reaches the
     * time limit, SageMaker ends the training job. Use this API to cap model training
     * costs.

To stop a job, SageMaker sends the algorithm the
     * SIGTERM signal, which delays job termination for 120 seconds.
     * Algorithms can use this 120-second window to save the model artifacts, so the
     * results of training are not lost.

     */
    inline void SetStoppingCondition(StoppingCondition&& value) { m_stoppingConditionHasBeenSet = true; m_stoppingCondition = std::move(value); }

    /**
     *
Specifies a limit to how long a model training job can run. It also specifies
     * how long a managed Spot training job has to complete. When the job reaches the
     * time limit, SageMaker ends the training job. Use this API to cap model training
     * costs.

To stop a job, SageMaker sends the algorithm the
     * SIGTERM signal, which delays job termination for 120 seconds.
     * Algorithms can use this 120-second window to save the model artifacts, so the
     * results of training are not lost.

     */
    inline CreateTrainingJobRequest& WithStoppingCondition(const StoppingCondition& value) { SetStoppingCondition(value); return *this;}

    /**
     *
Specifies a limit to how long a model training job can run. It also specifies
     * how long a managed Spot training job has to complete. When the job reaches the
     * time limit, SageMaker ends the training job. Use this API to cap model training
     * costs.

To stop a job, SageMaker sends the algorithm the
     * SIGTERM signal, which delays job termination for 120 seconds.
     * Algorithms can use this 120-second window to save the model artifacts, so the
     * results of training are not lost.

     */
    inline CreateTrainingJobRequest& WithStoppingCondition(StoppingCondition&& value) { SetStoppingCondition(std::move(value)); return *this;}

    /**
     *
An array of key-value pairs. You can use tags to categorize your Amazon Web
     * Services resources in different ways, for example, by purpose, owner, or
     * environment. For more information, see Tagging
     * Amazon Web Services Resources.

     */
    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }

    /**
     *
An array of key-value pairs. You can use tags to categorize your Amazon Web
     * Services resources in different ways, for example, by purpose, owner, or
     * environment. For more information, see Tagging
     * Amazon Web Services Resources.

     */
    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }

    /**
     *
An array of key-value pairs. You can use tags to categorize your Amazon Web
     * Services resources in different ways, for example, by purpose, owner, or
     * environment. For more information, see Tagging
     * Amazon Web Services Resources.

     */
    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }

    /**
     *
An array of key-value pairs. You can use tags to categorize your Amazon Web
     * Services resources in different ways, for example, by purpose, owner, or
     * environment. For more information, see Tagging
     * Amazon Web Services Resources.

     */
    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }

    /**
     *
An array of key-value pairs. You can use tags to categorize your Amazon Web
     * Services resources in different ways, for example, by purpose, owner, or
     * environment. For more information, see Tagging
     * Amazon Web Services Resources.

     */
    inline CreateTrainingJobRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}

    /**
     *
An array of key-value pairs. You can use tags to categorize your Amazon Web
     * Services resources in different ways, for example, by purpose, owner, or
     * environment. For more information, see Tagging
     * Amazon Web Services Resources.

     */
    inline CreateTrainingJobRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}

    /**
     *
An array of key-value pairs. You can use tags to categorize your Amazon Web
     * Services resources in different ways, for example, by purpose, owner, or
     * environment. For more information, see Tagging
     * Amazon Web Services Resources.

     */
    inline CreateTrainingJobRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }

    /**
     *
An array of key-value pairs. You can use tags to categorize your Amazon Web
     * Services resources in different ways, for example, by purpose, owner, or
     * environment. For more information, see Tagging
     * Amazon Web Services Resources.

     */
    inline CreateTrainingJobRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }

    /**
     *
Isolates the training container. No inbound or outbound network calls can be
     * made, except for calls between peers within a training cluster for distributed
     * training. If you enable network isolation for training jobs that are configured
     * to use a VPC, SageMaker downloads and uploads customer data and model artifacts
     * through the specified VPC, but the training container does not have network
     * access.

     */
    inline bool GetEnableNetworkIsolation() const{ return m_enableNetworkIsolation; }

    /**
     *
Isolates the training container. No inbound or outbound network calls can be
     * made, except for calls between peers within a training cluster for distributed
     * training. If you enable network isolation for training jobs that are configured
     * to use a VPC, SageMaker downloads and uploads customer data and model artifacts
     * through the specified VPC, but the training container does not have network
     * access.

     */
    inline bool EnableNetworkIsolationHasBeenSet() const { return m_enableNetworkIsolationHasBeenSet; }

    /**
     *
Isolates the training container. No inbound or outbound network calls can be
     * made, except for calls between peers within a training cluster for distributed
     * training. If you enable network isolation for training jobs that are configured
     * to use a VPC, SageMaker downloads and uploads customer data and model artifacts
     * through the specified VPC, but the training container does not have network
     * access.

     */
    inline void SetEnableNetworkIsolation(bool value) { m_enableNetworkIsolationHasBeenSet = true; m_enableNetworkIsolation = value; }

    /**
     *
Isolates the training container. No inbound or outbound network calls can be
     * made, except for calls between peers within a training cluster for distributed
     * training. If you enable network isolation for training jobs that are configured
     * to use a VPC, SageMaker downloads and uploads customer data and model artifacts
     * through the specified VPC, but the training container does not have network
     * access.

     */
    inline CreateTrainingJobRequest& WithEnableNetworkIsolation(bool value) { SetEnableNetworkIsolation(value); return *this;}

    /**
     *
To encrypt all communications between ML compute instances in distributed
     * training, choose True. Encryption provides greater security for
     * distributed training, but training might take longer. How long it takes depends
     * on the amount of communication between compute instances, especially if you use
     * a deep learning algorithm in distributed training. For more information, see Protect
     * Communications Between ML Compute Instances in a Distributed Training
     * Job.

     */
    inline bool GetEnableInterContainerTrafficEncryption() const{ return m_enableInterContainerTrafficEncryption; }

    /**
     *
To encrypt all communications between ML compute instances in distributed
     * training, choose True. Encryption provides greater security for
     * distributed training, but training might take longer. How long it takes depends
     * on the amount of communication between compute instances, especially if you use
     * a deep learning algorithm in distributed training. For more information, see Protect
     * Communications Between ML Compute Instances in a Distributed Training
     * Job.

     */
    inline bool EnableInterContainerTrafficEncryptionHasBeenSet() const { return m_enableInterContainerTrafficEncryptionHasBeenSet; }

    /**
     *
To encrypt all communications between ML compute instances in distributed
     * training, choose True. Encryption provides greater security for
     * distributed training, but training might take longer. How long it takes depends
     * on the amount of communication between compute instances, especially if you use
     * a deep learning algorithm in distributed training. For more information, see Protect
     * Communications Between ML Compute Instances in a Distributed Training
     * Job.

     */
    inline void SetEnableInterContainerTrafficEncryption(bool value) { m_enableInterContainerTrafficEncryptionHasBeenSet = true; m_enableInterContainerTrafficEncryption = value; }

    /**
     *
To encrypt all communications between ML compute instances in distributed
     * training, choose True. Encryption provides greater security for
     * distributed training, but training might take longer. How long it takes depends
     * on the amount of communication between compute instances, especially if you use
     * a deep learning algorithm in distributed training. For more information, see Protect
     * Communications Between ML Compute Instances in a Distributed Training
     * Job.

     */
    inline CreateTrainingJobRequest& WithEnableInterContainerTrafficEncryption(bool value) { SetEnableInterContainerTrafficEncryption(value); return *this;}

    /**
     *
To train models using managed spot training, choose True.
     * Managed spot training provides a fully managed and scalable infrastructure for
     * training machine learning models. this option is useful when training jobs can
     * be interrupted and when there is flexibility when the training job is run.

     *
The complete and intermediate results of jobs are stored in an Amazon S3
     * bucket, and can be used as a starting point to train models incrementally.
     * Amazon SageMaker provides metrics and logs in CloudWatch. They can be used to
     * see when managed spot training jobs are running, interrupted, resumed, or
     * completed.

     */
    inline bool GetEnableManagedSpotTraining() const{ return m_enableManagedSpotTraining; }

    /**
     *
To train models using managed spot training, choose True.
     * Managed spot training provides a fully managed and scalable infrastructure for
     * training machine learning models. this option is useful when training jobs can
     * be interrupted and when there is flexibility when the training job is run.

     *
The complete and intermediate results of jobs are stored in an Amazon S3
     * bucket, and can be used as a starting point to train models incrementally.
     * Amazon SageMaker provides metrics and logs in CloudWatch. They can be used to
     * see when managed spot training jobs are running, interrupted, resumed, or
     * completed.

     */
    inline bool EnableManagedSpotTrainingHasBeenSet() const { return m_enableManagedSpotTrainingHasBeenSet; }

    /**
     *
To train models using managed spot training, choose True.
     * Managed spot training provides a fully managed and scalable infrastructure for
     * training machine learning models. this option is useful when training jobs can
     * be interrupted and when there is flexibility when the training job is run.

     *
The complete and intermediate results of jobs are stored in an Amazon S3
     * bucket, and can be used as a starting point to train models incrementally.
     * Amazon SageMaker provides metrics and logs in CloudWatch. They can be used to
     * see when managed spot training jobs are running, interrupted, resumed, or
     * completed.

     */
    inline void SetEnableManagedSpotTraining(bool value) { m_enableManagedSpotTrainingHasBeenSet = true; m_enableManagedSpotTraining = value; }

    /**
     *
To train models using managed spot training, choose True.
     * Managed spot training provides a fully managed and scalable infrastructure for
     * training machine learning models. this option is useful when training jobs can
     * be interrupted and when there is flexibility when the training job is run.

     *
The complete and intermediate results of jobs are stored in an Amazon S3
     * bucket, and can be used as a starting point to train models incrementally.
     * Amazon SageMaker provides metrics and logs in CloudWatch. They can be used to
     * see when managed spot training jobs are running, interrupted, resumed, or
     * completed.

     */
    inline CreateTrainingJobRequest& WithEnableManagedSpotTraining(bool value) { SetEnableManagedSpotTraining(value); return *this;}

    /**
     *
Contains information about the output location for managed spot training
     * checkpoint data.

     */
    inline const CheckpointConfig& GetCheckpointConfig() const{ return m_checkpointConfig; }

    /**
     *
Contains information about the output location for managed spot training
     * checkpoint data.

     */
    inline bool CheckpointConfigHasBeenSet() const { return m_checkpointConfigHasBeenSet; }

    /**
     *
Contains information about the output location for managed spot training
     * checkpoint data.

     */
    inline void SetCheckpointConfig(const CheckpointConfig& value) { m_checkpointConfigHasBeenSet = true; m_checkpointConfig = value; }

    /**
     *
Contains information about the output location for managed spot training
     * checkpoint data.

     */
    inline void SetCheckpointConfig(CheckpointConfig&& value) { m_checkpointConfigHasBeenSet = true; m_checkpointConfig = std::move(value); }

    /**
     *
Contains information about the output location for managed spot training
     * checkpoint data.

     */
    inline CreateTrainingJobRequest& WithCheckpointConfig(const CheckpointConfig& value) { SetCheckpointConfig(value); return *this;}

    /**
     *
Contains information about the output location for managed spot training
     * checkpoint data.

     */
    inline CreateTrainingJobRequest& WithCheckpointConfig(CheckpointConfig&& value) { SetCheckpointConfig(std::move(value)); return *this;}

    inline const DebugHookConfig& GetDebugHookConfig() const{ return m_debugHookConfig; }

    inline bool DebugHookConfigHasBeenSet() const { return m_debugHookConfigHasBeenSet; }

    inline void SetDebugHookConfig(const DebugHookConfig& value) { m_debugHookConfigHasBeenSet = true; m_debugHookConfig = value; }

    inline void SetDebugHookConfig(DebugHookConfig&& value) { m_debugHookConfigHasBeenSet = true; m_debugHookConfig = std::move(value); }

    inline CreateTrainingJobRequest& WithDebugHookConfig(const DebugHookConfig& value) { SetDebugHookConfig(value); return *this;}

    inline CreateTrainingJobRequest& WithDebugHookConfig(DebugHookConfig&& value) { SetDebugHookConfig(std::move(value)); return *this;}

    /**
     *
Configuration information for Debugger rules for debugging output
     * tensors.

     */
    inline const Aws::Vector<DebugRuleConfiguration>& GetDebugRuleConfigurations() const{ return m_debugRuleConfigurations; }

    /**
     *
Configuration information for Debugger rules for debugging output
     * tensors.

     */
    inline bool DebugRuleConfigurationsHasBeenSet() const { return m_debugRuleConfigurationsHasBeenSet; }

    /**
     *
Configuration information for Debugger rules for debugging output
     * tensors.

     */
    inline void SetDebugRuleConfigurations(const Aws::Vector<DebugRuleConfiguration>& value) { m_debugRuleConfigurationsHasBeenSet = true; m_debugRuleConfigurations = value; }

    /**
     *
Configuration information for Debugger rules for debugging output
     * tensors.

     */
    inline void SetDebugRuleConfigurations(Aws::Vector<DebugRuleConfiguration>&& value) { m_debugRuleConfigurationsHasBeenSet = true; m_debugRuleConfigurations = std::move(value); }

    /**
     *
Configuration information for Debugger rules for debugging output
     * tensors.

     */
    inline CreateTrainingJobRequest& WithDebugRuleConfigurations(const Aws::Vector<DebugRuleConfiguration>& value) { SetDebugRuleConfigurations(value); return *this;}

    /**
     *
Configuration information for Debugger rules for debugging output
     * tensors.

     */
    inline CreateTrainingJobRequest& WithDebugRuleConfigurations(Aws::Vector<DebugRuleConfiguration>&& value) { SetDebugRuleConfigurations(std::move(value)); return *this;}

    /**
     *
Configuration information for Debugger rules for debugging output
     * tensors.

     */
    inline CreateTrainingJobRequest& AddDebugRuleConfigurations(const DebugRuleConfiguration& value) { m_debugRuleConfigurationsHasBeenSet = true; m_debugRuleConfigurations.push_back(value); return *this; }

    /**
     *
Configuration information for Debugger rules for debugging output
     * tensors.

     */
    inline CreateTrainingJobRequest& AddDebugRuleConfigurations(DebugRuleConfiguration&& value) { m_debugRuleConfigurationsHasBeenSet = true; m_debugRuleConfigurations.push_back(std::move(value)); return *this; }

    inline const TensorBoardOutputConfig& GetTensorBoardOutputConfig() const{ return m_tensorBoardOutputConfig; }

    inline bool TensorBoardOutputConfigHasBeenSet() const { return m_tensorBoardOutputConfigHasBeenSet; }

    inline void SetTensorBoardOutputConfig(const TensorBoardOutputConfig& value) { m_tensorBoardOutputConfigHasBeenSet = true; m_tensorBoardOutputConfig = value; }

    inline void SetTensorBoardOutputConfig(TensorBoardOutputConfig&& value) { m_tensorBoardOutputConfigHasBeenSet = true; m_tensorBoardOutputConfig = std::move(value); }

    inline CreateTrainingJobRequest& WithTensorBoardOutputConfig(const TensorBoardOutputConfig& value) { SetTensorBoardOutputConfig(value); return *this;}

    inline CreateTrainingJobRequest& WithTensorBoardOutputConfig(TensorBoardOutputConfig&& value) { SetTensorBoardOutputConfig(std::move(value)); return *this;}

    inline const ExperimentConfig& GetExperimentConfig() const{ return m_experimentConfig; }

    inline bool ExperimentConfigHasBeenSet() const { return m_experimentConfigHasBeenSet; }

    inline void SetExperimentConfig(const ExperimentConfig& value) { m_experimentConfigHasBeenSet = true; m_experimentConfig = value; }

    inline void SetExperimentConfig(ExperimentConfig&& value) { m_experimentConfigHasBeenSet = true; m_experimentConfig = std::move(value); }

    inline CreateTrainingJobRequest& WithExperimentConfig(const ExperimentConfig& value) { SetExperimentConfig(value); return *this;}

    inline CreateTrainingJobRequest& WithExperimentConfig(ExperimentConfig&& value) { SetExperimentConfig(std::move(value)); return *this;}

    inline const ProfilerConfig& GetProfilerConfig() const{ return m_profilerConfig; }

    inline bool ProfilerConfigHasBeenSet() const { return m_profilerConfigHasBeenSet; }

    inline void SetProfilerConfig(const ProfilerConfig& value) { m_profilerConfigHasBeenSet = true; m_profilerConfig = value; }

    inline void SetProfilerConfig(ProfilerConfig&& value) { m_profilerConfigHasBeenSet = true; m_profilerConfig = std::move(value); }

    inline CreateTrainingJobRequest& WithProfilerConfig(const ProfilerConfig& value) { SetProfilerConfig(value); return *this;}

    inline CreateTrainingJobRequest& WithProfilerConfig(ProfilerConfig&& value) { SetProfilerConfig(std::move(value)); return *this;}

    /**
     *
Configuration information for Debugger rules for profiling system and
     * framework metrics.

     */
    inline const Aws::Vector<ProfilerRuleConfiguration>& GetProfilerRuleConfigurations() const{ return m_profilerRuleConfigurations; }

    /**
     *
Configuration information for Debugger rules for profiling system and
     * framework metrics.

     */
    inline bool ProfilerRuleConfigurationsHasBeenSet() const { return m_profilerRuleConfigurationsHasBeenSet; }

    /**
     *
Configuration information for Debugger rules for profiling system and
     * framework metrics.

     */
    inline void SetProfilerRuleConfigurations(const Aws::Vector<ProfilerRuleConfiguration>& value) { m_profilerRuleConfigurationsHasBeenSet = true; m_profilerRuleConfigurations = value; }

    /**
     *
Configuration information for Debugger rules for profiling system and
     * framework metrics.

     */
    inline void SetProfilerRuleConfigurations(Aws::Vector<ProfilerRuleConfiguration>&& value) { m_profilerRuleConfigurationsHasBeenSet = true; m_profilerRuleConfigurations = std::move(value); }

    /**
     *
Configuration information for Debugger rules for profiling system and
     * framework metrics.

     */
    inline CreateTrainingJobRequest& WithProfilerRuleConfigurations(const Aws::Vector<ProfilerRuleConfiguration>& value) { SetProfilerRuleConfigurations(value); return *this;}

    /**
     *
Configuration information for Debugger rules for profiling system and
     * framework metrics.

     */
    inline CreateTrainingJobRequest& WithProfilerRuleConfigurations(Aws::Vector<ProfilerRuleConfiguration>&& value) { SetProfilerRuleConfigurations(std::move(value)); return *this;}

    /**
     *
Configuration information for Debugger rules for profiling system and
     * framework metrics.

     */
    inline CreateTrainingJobRequest& AddProfilerRuleConfigurations(const ProfilerRuleConfiguration& value) { m_profilerRuleConfigurationsHasBeenSet = true; m_profilerRuleConfigurations.push_back(value); return *this; }

    /**
     *
Configuration information for Debugger rules for profiling system and
     * framework metrics.

     */
    inline CreateTrainingJobRequest& AddProfilerRuleConfigurations(ProfilerRuleConfiguration&& value) { m_profilerRuleConfigurationsHasBeenSet = true; m_profilerRuleConfigurations.push_back(std::move(value)); return *this; }

    /**
     *
The environment variables to set in the Docker container.

     */
    inline const Aws::Map<Aws::String, Aws::String>& GetEnvironment() const{ return m_environment; }

    /**
     *
The environment variables to set in the Docker container.

     */
    inline bool EnvironmentHasBeenSet() const { return m_environmentHasBeenSet; }

    /**
     *
The environment variables to set in the Docker container.

     */
    inline void SetEnvironment(const Aws::Map<Aws::String, Aws::String>& value) { m_environmentHasBeenSet = true; m_environment = value; }

    /**
     *
The environment variables to set in the Docker container.

     */
    inline void SetEnvironment(Aws::Map<Aws::String, Aws::String>&& value) { m_environmentHasBeenSet = true; m_environment = std::move(value); }

    /**
     *
The environment variables to set in the Docker container.

     */
    inline CreateTrainingJobRequest& WithEnvironment(const Aws::Map<Aws::String, Aws::String>& value) { SetEnvironment(value); return *this;}

    /**
     *
The environment variables to set in the Docker container.

     */
    inline CreateTrainingJobRequest& WithEnvironment(Aws::Map<Aws::String, Aws::String>&& value) { SetEnvironment(std::move(value)); return *this;}

    /**
     *
The environment variables to set in the Docker container.

     */
    inline CreateTrainingJobRequest& AddEnvironment(const Aws::String& key, const Aws::String& value) { m_environmentHasBeenSet = true; m_environment.emplace(key, value); return *this; }

    /**
     *
The environment variables to set in the Docker container.

     */
    inline CreateTrainingJobRequest& AddEnvironment(Aws::String&& key, const Aws::String& value) { m_environmentHasBeenSet = true; m_environment.emplace(std::move(key), value); return *this; }

    /**
     *
The environment variables to set in the Docker container.

     */
    inline CreateTrainingJobRequest& AddEnvironment(const Aws::String& key, Aws::String&& value) { m_environmentHasBeenSet = true; m_environment.emplace(key, std::move(value)); return *this; }

    /**
     *
The environment variables to set in the Docker container.

     */
    inline CreateTrainingJobRequest& AddEnvironment(Aws::String&& key, Aws::String&& value) { m_environmentHasBeenSet = true; m_environment.emplace(std::move(key), std::move(value)); return *this; }

    /**
     *
The environment variables to set in the Docker container.

     */
    inline CreateTrainingJobRequest& AddEnvironment(const char* key, Aws::String&& value) { m_environmentHasBeenSet = true; m_environment.emplace(key, std::move(value)); return *this; }

    /**
     *
The environment variables to set in the Docker container.

     */
    inline CreateTrainingJobRequest& AddEnvironment(Aws::String&& key, const char* value) { m_environmentHasBeenSet = true; m_environment.emplace(std::move(key), value); return *this; }

    /**
     *
The environment variables to set in the Docker container.

     */
    inline CreateTrainingJobRequest& AddEnvironment(const char* key, const char* value) { m_environmentHasBeenSet = true; m_environment.emplace(key, value); return *this; }

    /**
     *
The number of times to retry the job when the job fails due to an
     * InternalServerError.

     */
    inline const RetryStrategy& GetRetryStrategy() const{ return m_retryStrategy; }

    /**
     *
The number of times to retry the job when the job fails due to an
     * InternalServerError.

     */
    inline bool RetryStrategyHasBeenSet() const { return m_retryStrategyHasBeenSet; }

    /**
     *
The number of times to retry the job when the job fails due to an
     * InternalServerError.

     */
    inline void SetRetryStrategy(const RetryStrategy& value) { m_retryStrategyHasBeenSet = true; m_retryStrategy = value; }

    /**
     *
The number of times to retry the job when the job fails due to an
     * InternalServerError.

     */
    inline void SetRetryStrategy(RetryStrategy&& value) { m_retryStrategyHasBeenSet = true; m_retryStrategy = std::move(value); }

    /**
     *
The number of times to retry the job when the job fails due to an
     * InternalServerError.

     */
    inline CreateTrainingJobRequest& WithRetryStrategy(const RetryStrategy& value) { SetRetryStrategy(value); return *this;}

    /**
     *
The number of times to retry the job when the job fails due to an
     * InternalServerError.

     */
    inline CreateTrainingJobRequest& WithRetryStrategy(RetryStrategy&& value) { SetRetryStrategy(std::move(value)); return *this;}

  private:

    Aws::String m_trainingJobName;
    bool m_trainingJobNameHasBeenSet;

    Aws::Map<Aws::String, Aws::String> m_hyperParameters;
    bool m_hyperParametersHasBeenSet;

    AlgorithmSpecification m_algorithmSpecification;
    bool m_algorithmSpecificationHasBeenSet;

    Aws::String m_roleArn;
    bool m_roleArnHasBeenSet;

    Aws::Vector<Channel> m_inputDataConfig;
    bool m_inputDataConfigHasBeenSet;

    OutputDataConfig m_outputDataConfig;
    bool m_outputDataConfigHasBeenSet;

    ResourceConfig m_resourceConfig;
    bool m_resourceConfigHasBeenSet;

    VpcConfig m_vpcConfig;
    bool m_vpcConfigHasBeenSet;

    StoppingCondition m_stoppingCondition;
    bool m_stoppingConditionHasBeenSet;

    Aws::Vector<Tag> m_tags;
    bool m_tagsHasBeenSet;

    bool m_enableNetworkIsolation;
    bool m_enableNetworkIsolationHasBeenSet;

    bool m_enableInterContainerTrafficEncryption;
    bool m_enableInterContainerTrafficEncryptionHasBeenSet;

    bool m_enableManagedSpotTraining;
    bool m_enableManagedSpotTrainingHasBeenSet;

    CheckpointConfig m_checkpointConfig;
    bool m_checkpointConfigHasBeenSet;

    DebugHookConfig m_debugHookConfig;
    bool m_debugHookConfigHasBeenSet;

    Aws::Vector<DebugRuleConfiguration> m_debugRuleConfigurations;
    bool m_debugRuleConfigurationsHasBeenSet;

    TensorBoardOutputConfig m_tensorBoardOutputConfig;
    bool m_tensorBoardOutputConfigHasBeenSet;

    ExperimentConfig m_experimentConfig;
    bool m_experimentConfigHasBeenSet;

    ProfilerConfig m_profilerConfig;
    bool m_profilerConfigHasBeenSet;

    Aws::Vector<ProfilerRuleConfiguration> m_profilerRuleConfigurations;
    bool m_profilerRuleConfigurationsHasBeenSet;

    Aws::Map<Aws::String, Aws::String> m_environment;
    bool m_environmentHasBeenSet;

    RetryStrategy m_retryStrategy;
    bool m_retryStrategyHasBeenSet;
  };

} // namespace Model
} // namespace SageMaker
} // namespace Aws


text:
:mod:`pyspv.transactionbuilder` --- Build new transactions
==========================================================

.. autoclass:: pyspv.transactionbuilder.TransactionBuilder
   :members:
   :undoc-members:

redpajama_set_name: RedPajamaGithub


text:
BOT_NAME = 'f6a_tw_scrapy'

SPIDER_MODULES = ['f6a_tw_scrapy.spiders']
NEWSPIDER_MODULE = 'f6a_tw_scrapy.spiders'

# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = 'f6a_tw_scrapy (+http://www.yourdomain.com)'


text:
// Copyright (c) 2010-2014 SharpDX - Alexandre Mutel
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Threading;
using System.Xml.Serialization;

namespace SharpGen
{
    /// <summary>
    /// Utility class.
    /// </summary>
    public static class Utilities
    {
        /// <summary>
        /// Escapes the xml/html text in order to use it inside xml.
        /// </summary>
        /// <param name="stringToEscape">The string to escape.</param>
        /// <returns></returns>
        public static string EscapeXml(string stringToEscape)
        {
            return stringToEscape.Replace("&", "&").Replace("<", "<").Replace(">", ">").Replace("\"", """).Replace("'", "'");
        }

        /// <summary>
        /// Gets a resource from this assembly.
        /// </summary>
        /// <param name="resourceName">The resource name.</param>
        /// <returns>The text of resource</returns>
        public static string GetResourceAsString(string resourceName)
        {
            Assembly asm = Assembly.GetExecutingAssembly();

            string val = "";
            //' resources are named using a fully qualified name
            Stream strm = asm.GetManifestResourceStream(typeof (Utilities).Namespace + "." + resourceName);

            //' read the contents of the embedded file
            var reader = new StreamReader(strm);
            val = reader.ReadToEnd();
            reader.Close();

            return val;
        }

        /// <summary>
        /// Imports the XML types.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="mappings">The mappings.</param>
        /// <param name="importedTypes">The imported types.</param>
        /// <param name="importer">The importer.</param>
        private static void ImportXmlTypes(Type type, List<XmlMapping> mappings, List<Type> importedTypes, XmlReflectionImporter importer)
        {
            XmlTypeMapping mapping = null;
            var importer2 = new XmlReflectionImporter();
            try
            {
                mapping = importer2.ImportTypeMapping(type);
            }
            catch (Exception exception)
            {
                if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
                {
                    throw;
                }
                return;
            }
            if (mapping != null)
            {
                mapping = importer.ImportTypeMapping(type);
                mappings.Add(mapping);
                importedTypes.Add(type);
            }
        }

        /// <summary>
        /// Generates XmlSerializers assembly for this assembly, allowing faster startup with xml serialization.
        /// </summary>
        public static void SGenThisAssembly()
        {
            var xmlRootTypes = new List<Type>();
            var assembly = typeof(Utilities).Assembly;
            var mappings = new List<XmlMapping>();
            var allXmlTypeToSerialize = new List<Type>();
            var importer = new XmlReflectionImporter();

            foreach (var type in assembly.GetTypes())
            {
                if (type.GetCustomAttributes(typeof(XmlRootAttribute), true).Length > 0)
                {
                    xmlRootTypes.Add(type);
                    ImportXmlTypes(type, mappings, allXmlTypeToSerialize, importer);
                }
            }

            if (allXmlTypeToSerialize.Count == 0)
                return;

            string assemblySerializer = XmlSerializer.GetXmlSerializerAssemblyName(allXmlTypeToSerialize[0], null) + ".dll";
            var assemblySerializerTime = File.GetLastWriteTime(assemblySerializer);

            if (!File.Exists(assemblySerializer) || File.GetLastWriteTime(typeof(Utilities).Assembly.Location) > assemblySerializerTime)
            {
                // Delete previous assembly
                File.Delete(assemblySerializer);

                // Regenerate assembly
                var parameters = new CompilerParameters();
                string codePath = Path.GetDirectoryName(assembly.Location);
                var files = new TempFileCollection(codePath, false);
                parameters.TempFiles = files;
                parameters.GenerateInMemory = false;
                parameters.IncludeDebugInformation = true;
                parameters.GenerateInMemory = false;
                XmlSerializer.GenerateSerializer(allXmlTypeToSerialize.ToArray(), mappings.ToArray(), parameters);
                files.Delete();
            }
            else
            {
                Assembly.LoadFrom(assemblySerializer);
            }
        }

		/// <summary>
		/// Determines whether a string contains a given C++ identifier.
		/// </summary>
		/// <param name="str">The string to search.</param>
		/// <param name="identifier">The C++ identifier to search for.</param>
		/// <returns></returns>
		public static bool ContainsCppIdentifier(string str, string identifier)
		{
			if (string.IsNullOrEmpty(str))
				return string.IsNullOrEmpty(identifier);

			return Regex.IsMatch(str, string.Format(@"\b{0}\b", Regex.Escape(identifier)), RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
		}
    }
}


text:
package com.eljavatar.swingutils.core.modelcomponents;

/**
 *
 * @author ElJavatar - Andres Mauricio (http://www.eljavatar.com)
 */
public enum FilterMatchModeEnum {

    CONTAINS,
    EXACT,
    STARTS_WITH,
    ENDS_WITH;

}