//go:build go1.18
// +build go1.18

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
// Code generated by Microsoft (R) AutoRest Code Generator. DO NOT EDIT.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

package armmachinelearning

const (
	moduleName    = "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/machinelearning/armmachinelearning"
	moduleVersion = "v4.0.0"
)

// ActionType - Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.
type ActionType string

const (
	ActionTypeInternal ActionType = "Internal"
)

// PossibleActionTypeValues returns the possible values for the ActionType const type.
func PossibleActionTypeValues() []ActionType {
	return []ActionType{
		ActionTypeInternal,
	}
}

// AllocationState - Allocation state of the compute. Possible values are: steady - Indicates that the compute is not resizing.
// There are no changes to the number of compute nodes in the compute in progress. A compute
// enters this state when it is created and when no operations are being performed on the compute to change the number of
// compute nodes. resizing - Indicates that the compute is resizing; that is,
// compute nodes are being added to or removed from the compute.
type AllocationState string

const (
	AllocationStateResizing AllocationState = "Resizing"
	AllocationStateSteady   AllocationState = "Steady"
)

// PossibleAllocationStateValues returns the possible values for the AllocationState const type.
func PossibleAllocationStateValues() []AllocationState {
	return []AllocationState{
		AllocationStateResizing,
		AllocationStateSteady,
	}
}

// ApplicationSharingPolicy - Policy for sharing applications on this compute instance among users of parent workspace. If
// Personal, only the creator can access applications on this compute instance. When Shared, any workspace
// user can access applications on this instance depending on his/her assigned role.
type ApplicationSharingPolicy string

const (
	ApplicationSharingPolicyPersonal ApplicationSharingPolicy = "Personal"
	ApplicationSharingPolicyShared   ApplicationSharingPolicy = "Shared"
)

// PossibleApplicationSharingPolicyValues returns the possible values for the ApplicationSharingPolicy const type.
func PossibleApplicationSharingPolicyValues() []ApplicationSharingPolicy {
	return []ApplicationSharingPolicy{
		ApplicationSharingPolicyPersonal,
		ApplicationSharingPolicyShared,
	}
}

// AssetProvisioningState - Provisioning state of registry asset.
type AssetProvisioningState string

const (
	AssetProvisioningStateCanceled  AssetProvisioningState = "Canceled"
	AssetProvisioningStateCreating  AssetProvisioningState = "Creating"
	AssetProvisioningStateDeleting  AssetProvisioningState = "Deleting"
	AssetProvisioningStateFailed    AssetProvisioningState = "Failed"
	AssetProvisioningStateSucceeded AssetProvisioningState = "Succeeded"
	AssetProvisioningStateUpdating  AssetProvisioningState = "Updating"
)

// PossibleAssetProvisioningStateValues returns the possible values for the AssetProvisioningState const type.
func PossibleAssetProvisioningStateValues() []AssetProvisioningState {
	return []AssetProvisioningState{
		AssetProvisioningStateCanceled,
		AssetProvisioningStateCreating,
		AssetProvisioningStateDeleting,
		AssetProvisioningStateFailed,
		AssetProvisioningStateSucceeded,
		AssetProvisioningStateUpdating,
	}
}

// AutoRebuildSetting - AutoRebuild setting for the derived image
type AutoRebuildSetting string

const (
	AutoRebuildSettingDisabled          AutoRebuildSetting = "Disabled"
	AutoRebuildSettingOnBaseImageUpdate AutoRebuildSetting = "OnBaseImageUpdate"
)

// PossibleAutoRebuildSettingValues returns the possible values for the AutoRebuildSetting const type.
func PossibleAutoRebuildSettingValues() []AutoRebuildSetting {
	return []AutoRebuildSetting{
		AutoRebuildSettingDisabled,
		AutoRebuildSettingOnBaseImageUpdate,
	}
}

// Autosave - Auto save settings.
type Autosave string

const (
	AutosaveLocal  Autosave = "Local"
	AutosaveNone   Autosave = "None"
	AutosaveRemote Autosave = "Remote"
)

// PossibleAutosaveValues returns the possible values for the Autosave const type.
func PossibleAutosaveValues() []Autosave {
	return []Autosave{
		AutosaveLocal,
		AutosaveNone,
		AutosaveRemote,
	}
}

// BatchDeploymentConfigurationType - The enumerated property types for batch deployments.
type BatchDeploymentConfigurationType string

const (
	BatchDeploymentConfigurationTypeModel             BatchDeploymentConfigurationType = "Model"
	BatchDeploymentConfigurationTypePipelineComponent BatchDeploymentConfigurationType = "PipelineComponent"
)

// PossibleBatchDeploymentConfigurationTypeValues returns the possible values for the BatchDeploymentConfigurationType const type.
func PossibleBatchDeploymentConfigurationTypeValues() []BatchDeploymentConfigurationType {
	return []BatchDeploymentConfigurationType{
		BatchDeploymentConfigurationTypeModel,
		BatchDeploymentConfigurationTypePipelineComponent,
	}
}

// BatchLoggingLevel - Log verbosity for batch inferencing. Increasing verbosity order for logging is : Warning, Info and
// Debug. The default value is Info.
type BatchLoggingLevel string

const (
	BatchLoggingLevelDebug   BatchLoggingLevel = "Debug"
	BatchLoggingLevelInfo    BatchLoggingLevel = "Info"
	BatchLoggingLevelWarning BatchLoggingLevel = "Warning"
)

// PossibleBatchLoggingLevelValues returns the possible values for the BatchLoggingLevel const type.
func PossibleBatchLoggingLevelValues() []BatchLoggingLevel {
	return []BatchLoggingLevel{
		BatchLoggingLevelDebug,
		BatchLoggingLevelInfo,
		BatchLoggingLevelWarning,
	}
}

// BatchOutputAction - Enum to determine how batch inferencing will handle output
type BatchOutputAction string

const (
	BatchOutputActionAppendRow   BatchOutputAction = "AppendRow"
	BatchOutputActionSummaryOnly BatchOutputAction = "SummaryOnly"
)

// PossibleBatchOutputActionValues returns the possible values for the BatchOutputAction const type.
func PossibleBatchOutputActionValues() []BatchOutputAction {
	return []BatchOutputAction{
		BatchOutputActionAppendRow,
		BatchOutputActionSummaryOnly,
	}
}

// BillingCurrency - Three lettered code specifying the currency of the VM price. Example: USD
type BillingCurrency string

const (
	BillingCurrencyUSD BillingCurrency = "USD"
)

// PossibleBillingCurrencyValues returns the possible values for the BillingCurrency const type.
func PossibleBillingCurrencyValues() []BillingCurrency {
	return []BillingCurrency{
		BillingCurrencyUSD,
	}
}

// BlockedTransformers - Enum for all classification models supported by AutoML.
type BlockedTransformers string

const (
	// BlockedTransformersCatTargetEncoder - Target encoding for categorical data.
	BlockedTransformersCatTargetEncoder BlockedTransformers = "CatTargetEncoder"
	// BlockedTransformersCountVectorizer - Count Vectorizer converts a collection of text documents to a matrix of token counts.
	BlockedTransformersCountVectorizer BlockedTransformers = "CountVectorizer"
	// BlockedTransformersHashOneHotEncoder - Hashing One Hot Encoder can turn categorical variables into a limited number of
	// new features. This is often used for high-cardinality categorical features.
	BlockedTransformersHashOneHotEncoder BlockedTransformers = "HashOneHotEncoder"
	// BlockedTransformersLabelEncoder - Label encoder converts labels/categorical variables in a numerical form.
	BlockedTransformersLabelEncoder BlockedTransformers = "LabelEncoder"
	// BlockedTransformersNaiveBayes - Naive Bayes is a classified that is used for classification of discrete features that are
	// categorically distributed.
	BlockedTransformersNaiveBayes BlockedTransformers = "NaiveBayes"
	// BlockedTransformersOneHotEncoder - Ohe hot encoding creates a binary feature transformation.
	BlockedTransformersOneHotEncoder BlockedTransformers = "OneHotEncoder"
	// BlockedTransformersTextTargetEncoder - Target encoding for text data.
	BlockedTransformersTextTargetEncoder BlockedTransformers = "TextTargetEncoder"
	// BlockedTransformersTfIdf - Tf-Idf stands for, term-frequency times inverse document-frequency. This is a common term weighting
	// scheme for identifying information from documents.
	BlockedTransformersTfIdf BlockedTransformers = "TfIdf"
	// BlockedTransformersWoETargetEncoder - Weight of Evidence encoding is a technique used to encode categorical variables.
	// It uses the natural log of the P(1)/P(0) to create weights.
	BlockedTransformersWoETargetEncoder BlockedTransformers = "WoETargetEncoder"
	// BlockedTransformersWordEmbedding - Word embedding helps represents words or phrases as a vector, or a series of numbers.
	BlockedTransformersWordEmbedding BlockedTransformers = "WordEmbedding"
)

// PossibleBlockedTransformersValues returns the possible values for the BlockedTransformers const type.
func PossibleBlockedTransformersValues() []BlockedTransformers {
	return []BlockedTransformers{
		BlockedTransformersCatTargetEncoder,
		BlockedTransformersCountVectorizer,
		BlockedTransformersHashOneHotEncoder,
		BlockedTransformersLabelEncoder,
		BlockedTransformersNaiveBayes,
		BlockedTransformersOneHotEncoder,
		BlockedTransformersTextTargetEncoder,
		BlockedTransformersTfIdf,
		BlockedTransformersWoETargetEncoder,
		BlockedTransformersWordEmbedding,
	}
}

// Caching - Caching type of Data Disk.
type Caching string

const (
	CachingNone      Caching = "None"
	CachingReadOnly  Caching = "ReadOnly"
	CachingReadWrite Caching = "ReadWrite"
)

// PossibleCachingValues returns the possible values for the Caching const type.
func PossibleCachingValues() []Caching {
	return []Caching{
		CachingNone,
		CachingReadOnly,
		CachingReadWrite,
	}
}

type CategoricalDataDriftMetric string

const (
	// CategoricalDataDriftMetricJensenShannonDistance - The Jensen Shannon Distance (JSD) metric.
	CategoricalDataDriftMetricJensenShannonDistance CategoricalDataDriftMetric = "JensenShannonDistance"
	// CategoricalDataDriftMetricPearsonsChiSquaredTest - The Pearsons Chi Squared Test metric.
	CategoricalDataDriftMetricPearsonsChiSquaredTest CategoricalDataDriftMetric = "PearsonsChiSquaredTest"
	// CategoricalDataDriftMetricPopulationStabilityIndex - The Population Stability Index (PSI) metric.
	CategoricalDataDriftMetricPopulationStabilityIndex CategoricalDataDriftMetric = "PopulationStabilityIndex"
)

// PossibleCategoricalDataDriftMetricValues returns the possible values for the CategoricalDataDriftMetric const type.
func PossibleCategoricalDataDriftMetricValues() []CategoricalDataDriftMetric {
	return []CategoricalDataDriftMetric{
		CategoricalDataDriftMetricJensenShannonDistance,
		CategoricalDataDriftMetricPearsonsChiSquaredTest,
		CategoricalDataDriftMetricPopulationStabilityIndex,
	}
}

type CategoricalDataQualityMetric string

const (
	// CategoricalDataQualityMetricDataTypeErrorRate - Calculates the rate of data type errors.
	CategoricalDataQualityMetricDataTypeErrorRate CategoricalDataQualityMetric = "DataTypeErrorRate"
	// CategoricalDataQualityMetricNullValueRate - Calculates the rate of null values.
	CategoricalDataQualityMetricNullValueRate CategoricalDataQualityMetric = "NullValueRate"
	// CategoricalDataQualityMetricOutOfBoundsRate - Calculates the rate values are out of bounds.
	CategoricalDataQualityMetricOutOfBoundsRate CategoricalDataQualityMetric = "OutOfBoundsRate"
)

// PossibleCategoricalDataQualityMetricValues returns the possible values for the CategoricalDataQualityMetric const type.
func PossibleCategoricalDataQualityMetricValues() []CategoricalDataQualityMetric {
	return []CategoricalDataQualityMetric{
		CategoricalDataQualityMetricDataTypeErrorRate,
		CategoricalDataQualityMetricNullValueRate,
		CategoricalDataQualityMetricOutOfBoundsRate,
	}
}

type CategoricalPredictionDriftMetric string

const (
	// CategoricalPredictionDriftMetricJensenShannonDistance - The Jensen Shannon Distance (JSD) metric.
	CategoricalPredictionDriftMetricJensenShannonDistance CategoricalPredictionDriftMetric = "JensenShannonDistance"
	// CategoricalPredictionDriftMetricPearsonsChiSquaredTest - The Pearsons Chi Squared Test metric.
	CategoricalPredictionDriftMetricPearsonsChiSquaredTest CategoricalPredictionDriftMetric = "PearsonsChiSquaredTest"
	// CategoricalPredictionDriftMetricPopulationStabilityIndex - The Population Stability Index (PSI) metric.
	CategoricalPredictionDriftMetricPopulationStabilityIndex CategoricalPredictionDriftMetric = "PopulationStabilityIndex"
)

// PossibleCategoricalPredictionDriftMetricValues returns the possible values for the CategoricalPredictionDriftMetric const type.
func PossibleCategoricalPredictionDriftMetricValues() []CategoricalPredictionDriftMetric {
	return []CategoricalPredictionDriftMetric{
		CategoricalPredictionDriftMetricJensenShannonDistance,
		CategoricalPredictionDriftMetricPearsonsChiSquaredTest,
		CategoricalPredictionDriftMetricPopulationStabilityIndex,
	}
}

// ClassificationModels - Enum for all classification models supported by AutoML.
type ClassificationModels string

const (
	// ClassificationModelsBernoulliNaiveBayes - Naive Bayes classifier for multivariate Bernoulli models.
	ClassificationModelsBernoulliNaiveBayes ClassificationModels = "BernoulliNaiveBayes"
	// ClassificationModelsDecisionTree - Decision Trees are a non-parametric supervised learning method used for both classification
	// and regression tasks.
	// The goal is to create a model that predicts the value of a target variable by learning simple decision rules inferred from
	// the data features.
	ClassificationModelsDecisionTree ClassificationModels = "DecisionTree"
	// ClassificationModelsExtremeRandomTrees - Extreme Trees is an ensemble machine learning algorithm that combines the predictions
	// from many decision trees. It is related to the widely used random forest algorithm.
	ClassificationModelsExtremeRandomTrees ClassificationModels = "ExtremeRandomTrees"
	// ClassificationModelsGradientBoosting - The technique of transiting week learners into a strong learner is called Boosting.
	// The gradient boosting algorithm process works on this theory of execution.
	ClassificationModelsGradientBoosting ClassificationModels = "GradientBoosting"
	// ClassificationModelsKNN - K-nearest neighbors (KNN) algorithm uses 'feature similarity' to predict the values of new datapoints
	// which further means that the new data point will be assigned a value based on how closely it matches the points in the
	// training set.
	ClassificationModelsKNN ClassificationModels = "KNN"
	// ClassificationModelsLightGBM - LightGBM is a gradient boosting framework that uses tree based learning algorithms.
	ClassificationModelsLightGBM ClassificationModels = "LightGBM"
	// ClassificationModelsLinearSVM - A support vector machine (SVM) is a supervised machine learning model that uses classification
	// algorithms for two-group classification problems.
	// After giving an SVM model sets of labeled training data for each category, they're able to categorize new text.
	// Linear SVM performs best when input data is linear, i.e., data can be easily classified by drawing the straight line between
	// classified values on a plotted graph.
	ClassificationModelsLinearSVM ClassificationModels = "LinearSVM"
	// ClassificationModelsLogisticRegression - Logistic regression is a fundamental classification technique.
	// It belongs to the group of linear classifiers and is somewhat similar to polynomial and linear regression.
	// Logistic regression is fast and relatively uncomplicated, and it's convenient for you to interpret the results.
	// Although it's essentially a method for binary classification, it can also be applied to multiclass problems.
	ClassificationModelsLogisticRegression ClassificationModels = "LogisticRegression"
	// ClassificationModelsMultinomialNaiveBayes - The multinomial Naive Bayes classifier is suitable for classification with
	// discrete features (e.g., word counts for text classification).
	// The multinomial distribution normally requires integer feature counts. However, in practice, fractional counts such as
	// tf-idf may also work.
	ClassificationModelsMultinomialNaiveBayes ClassificationModels = "MultinomialNaiveBayes"
	// ClassificationModelsRandomForest - Random forest is a supervised learning algorithm.
	// The "forest" it builds, is an ensemble of decision trees, usually trained with the “bagging” method.
	// The general idea of the bagging method is that a combination of learning models increases the overall result.
	ClassificationModelsRandomForest ClassificationModels = "RandomForest"
	// ClassificationModelsSGD - SGD: Stochastic gradient descent is an optimization algorithm often used in machine learning
	// applications
	// to find the model parameters that correspond to the best fit between predicted and actual outputs.
	ClassificationModelsSGD ClassificationModels = "SGD"
	// ClassificationModelsSVM - A support vector machine (SVM) is a supervised machine learning model that uses classification
	// algorithms for two-group classification problems.
	// After giving an SVM model sets of labeled training data for each category, they're able to categorize new text.
	ClassificationModelsSVM ClassificationModels = "SVM"
	// ClassificationModelsXGBoostClassifier - XGBoost: Extreme Gradient Boosting Algorithm. This algorithm is used for structured
	// data where target column values can be divided into distinct class values.
	ClassificationModelsXGBoostClassifier ClassificationModels = "XGBoostClassifier"
)

// PossibleClassificationModelsValues returns the possible values for the ClassificationModels const type.
func PossibleClassificationModelsValues() []ClassificationModels {
	return []ClassificationModels{
		ClassificationModelsBernoulliNaiveBayes,
		ClassificationModelsDecisionTree,
		ClassificationModelsExtremeRandomTrees,
		ClassificationModelsGradientBoosting,
		ClassificationModelsKNN,
		ClassificationModelsLightGBM,
		ClassificationModelsLinearSVM,
		ClassificationModelsLogisticRegression,
		ClassificationModelsMultinomialNaiveBayes,
		ClassificationModelsRandomForest,
		ClassificationModelsSGD,
		ClassificationModelsSVM,
		ClassificationModelsXGBoostClassifier,
	}
}

// ClassificationMultilabelPrimaryMetrics - Primary metrics for classification multilabel tasks.
type ClassificationMultilabelPrimaryMetrics string

const (
	// ClassificationMultilabelPrimaryMetricsAUCWeighted - AUC is the Area under the curve.
	// This metric represents arithmetic mean of the score for each class,
	// weighted by the number of true instances in each class.
	ClassificationMultilabelPrimaryMetricsAUCWeighted ClassificationMultilabelPrimaryMetrics = "AUCWeighted"
	// ClassificationMultilabelPrimaryMetricsAccuracy - Accuracy is the ratio of predictions that exactly match the true class
	// labels.
	ClassificationMultilabelPrimaryMetricsAccuracy ClassificationMultilabelPrimaryMetrics = "Accuracy"
	// ClassificationMultilabelPrimaryMetricsAveragePrecisionScoreWeighted - The arithmetic mean of the average precision score
	// for each class, weighted by
	// the number of true instances in each class.
	ClassificationMultilabelPrimaryMetricsAveragePrecisionScoreWeighted ClassificationMultilabelPrimaryMetrics = "AveragePrecisionScoreWeighted"
	// ClassificationMultilabelPrimaryMetricsIOU - Intersection Over Union. Intersection of predictions divided by union of predictions.
	ClassificationMultilabelPrimaryMetricsIOU ClassificationMultilabelPrimaryMetrics = "IOU"
	// ClassificationMultilabelPrimaryMetricsNormMacroRecall - Normalized macro recall is recall macro-averaged and normalized,
	// so that random
	// performance has a score of 0, and perfect performance has a score of 1.
	ClassificationMultilabelPrimaryMetricsNormMacroRecall ClassificationMultilabelPrimaryMetrics = "NormMacroRecall"
	// ClassificationMultilabelPrimaryMetricsPrecisionScoreWeighted - The arithmetic mean of precision for each class, weighted
	// by number of true instances in each class.
	ClassificationMultilabelPrimaryMetricsPrecisionScoreWeighted ClassificationMultilabelPrimaryMetrics = "PrecisionScoreWeighted"
)

// PossibleClassificationMultilabelPrimaryMetricsValues returns the possible values for the ClassificationMultilabelPrimaryMetrics const type.
func PossibleClassificationMultilabelPrimaryMetricsValues() []ClassificationMultilabelPrimaryMetrics {
	return []ClassificationMultilabelPrimaryMetrics{
		ClassificationMultilabelPrimaryMetricsAUCWeighted,
		ClassificationMultilabelPrimaryMetricsAccuracy,
		ClassificationMultilabelPrimaryMetricsAveragePrecisionScoreWeighted,
		ClassificationMultilabelPrimaryMetricsIOU,
		ClassificationMultilabelPrimaryMetricsNormMacroRecall,
		ClassificationMultilabelPrimaryMetricsPrecisionScoreWeighted,
	}
}

// ClassificationPrimaryMetrics - Primary metrics for classification tasks.
type ClassificationPrimaryMetrics string

const (
	// ClassificationPrimaryMetricsAUCWeighted - AUC is the Area under the curve.
	// This metric represents arithmetic mean of the score for each class,
	// weighted by the number of true instances in each class.
	ClassificationPrimaryMetricsAUCWeighted ClassificationPrimaryMetrics = "AUCWeighted"
	// ClassificationPrimaryMetricsAccuracy - Accuracy is the ratio of predictions that exactly match the true class labels.
	ClassificationPrimaryMetricsAccuracy ClassificationPrimaryMetrics = "Accuracy"
	// ClassificationPrimaryMetricsAveragePrecisionScoreWeighted - The arithmetic mean of the average precision score for each
	// class, weighted by
	// the number of true instances in each class.
	ClassificationPrimaryMetricsAveragePrecisionScoreWeighted ClassificationPrimaryMetrics = "AveragePrecisionScoreWeighted"
	// ClassificationPrimaryMetricsNormMacroRecall - Normalized macro recall is recall macro-averaged and normalized, so that
	// random
	// performance has a score of 0, and perfect performance has a score of 1.
	ClassificationPrimaryMetricsNormMacroRecall ClassificationPrimaryMetrics = "NormMacroRecall"
	// ClassificationPrimaryMetricsPrecisionScoreWeighted - The arithmetic mean of precision for each class, weighted by number
	// of true instances in each class.
	ClassificationPrimaryMetricsPrecisionScoreWeighted ClassificationPrimaryMetrics = "PrecisionScoreWeighted"
)

// PossibleClassificationPrimaryMetricsValues returns the possible values for the ClassificationPrimaryMetrics const type.
func PossibleClassificationPrimaryMetricsValues() []ClassificationPrimaryMetrics {
	return []ClassificationPrimaryMetrics{
		ClassificationPrimaryMetricsAUCWeighted,
		ClassificationPrimaryMetricsAccuracy,
		ClassificationPrimaryMetricsAveragePrecisionScoreWeighted,
		ClassificationPrimaryMetricsNormMacroRecall,
		ClassificationPrimaryMetricsPrecisionScoreWeighted,
	}
}

// ClusterPurpose - Intended usage of the cluster
type ClusterPurpose string

const (
	ClusterPurposeDenseProd ClusterPurpose = "DenseProd"
	ClusterPurposeDevTest   ClusterPurpose = "DevTest"
	ClusterPurposeFastProd  ClusterPurpose = "FastProd"
)

// PossibleClusterPurposeValues returns the possible values for the ClusterPurpose const type.
func PossibleClusterPurposeValues() []ClusterPurpose {
	return []ClusterPurpose{
		ClusterPurposeDenseProd,
		ClusterPurposeDevTest,
		ClusterPurposeFastProd,
	}
}

// ComputeInstanceAuthorizationType - The Compute Instance Authorization type. Available values are personal (default).
type ComputeInstanceAuthorizationType string

const (
	ComputeInstanceAuthorizationTypePersonal ComputeInstanceAuthorizationType = "personal"
)

// PossibleComputeInstanceAuthorizationTypeValues returns the possible values for the ComputeInstanceAuthorizationType const type.
func PossibleComputeInstanceAuthorizationTypeValues() []ComputeInstanceAuthorizationType {
	return []ComputeInstanceAuthorizationType{
		ComputeInstanceAuthorizationTypePersonal,
	}
}

// ComputeInstanceState - Current state of an ComputeInstance.
type ComputeInstanceState string

const (
	ComputeInstanceStateCreateFailed    ComputeInstanceState = "CreateFailed"
	ComputeInstanceStateCreating        ComputeInstanceState = "Creating"
	ComputeInstanceStateDeleting        ComputeInstanceState = "Deleting"
	ComputeInstanceStateJobRunning      ComputeInstanceState = "JobRunning"
	ComputeInstanceStateRestarting      ComputeInstanceState = "Restarting"
	ComputeInstanceStateRunning         ComputeInstanceState = "Running"
	ComputeInstanceStateSettingUp       ComputeInstanceState = "SettingUp"
	ComputeInstanceStateSetupFailed     ComputeInstanceState = "SetupFailed"
	ComputeInstanceStateStarting        ComputeInstanceState = "Starting"
	ComputeInstanceStateStopped         ComputeInstanceState = "Stopped"
	ComputeInstanceStateStopping        ComputeInstanceState = "Stopping"
	ComputeInstanceStateUnknown         ComputeInstanceState = "Unknown"
	ComputeInstanceStateUnusable        ComputeInstanceState = "Unusable"
	ComputeInstanceStateUserSettingUp   ComputeInstanceState = "UserSettingUp"
	ComputeInstanceStateUserSetupFailed ComputeInstanceState = "UserSetupFailed"
)

// PossibleComputeInstanceStateValues returns the possible values for the ComputeInstanceState const type.
func PossibleComputeInstanceStateValues() []ComputeInstanceState {
	return []ComputeInstanceState{
		ComputeInstanceStateCreateFailed,
		ComputeInstanceStateCreating,
		ComputeInstanceStateDeleting,
		ComputeInstanceStateJobRunning,
		ComputeInstanceStateRestarting,
		ComputeInstanceStateRunning,
		ComputeInstanceStateSettingUp,
		ComputeInstanceStateSetupFailed,
		ComputeInstanceStateStarting,
		ComputeInstanceStateStopped,
		ComputeInstanceStateStopping,
		ComputeInstanceStateUnknown,
		ComputeInstanceStateUnusable,
		ComputeInstanceStateUserSettingUp,
		ComputeInstanceStateUserSetupFailed,
	}
}

// ComputePowerAction - The compute power action.
type ComputePowerAction string

const (
	ComputePowerActionStart ComputePowerAction = "Start"
	ComputePowerActionStop  ComputePowerAction = "Stop"
)

// PossibleComputePowerActionValues returns the possible values for the ComputePowerAction const type.
func PossibleComputePowerActionValues() []ComputePowerAction {
	return []ComputePowerAction{
		ComputePowerActionStart,
		ComputePowerActionStop,
	}
}

// ComputeRecurrenceFrequency - Enum to describe the frequency of a compute recurrence schedule
type ComputeRecurrenceFrequency string

const (
	// ComputeRecurrenceFrequencyDay - Day frequency
	ComputeRecurrenceFrequencyDay ComputeRecurrenceFrequency = "Day"
	// ComputeRecurrenceFrequencyHour - Hour frequency
	ComputeRecurrenceFrequencyHour ComputeRecurrenceFrequency = "Hour"
	// ComputeRecurrenceFrequencyMinute - Minute frequency
	ComputeRecurrenceFrequencyMinute ComputeRecurrenceFrequency = "Minute"
	// ComputeRecurrenceFrequencyMonth - Month frequency
	ComputeRecurrenceFrequencyMonth ComputeRecurrenceFrequency = "Month"
	// ComputeRecurrenceFrequencyWeek - Week frequency
	ComputeRecurrenceFrequencyWeek ComputeRecurrenceFrequency = "Week"
)

// PossibleComputeRecurrenceFrequencyValues returns the possible values for the ComputeRecurrenceFrequency const type.
func PossibleComputeRecurrenceFrequencyValues() []ComputeRecurrenceFrequency {
	return []ComputeRecurrenceFrequency{
		ComputeRecurrenceFrequencyDay,
		ComputeRecurrenceFrequencyHour,
		ComputeRecurrenceFrequencyMinute,
		ComputeRecurrenceFrequencyMonth,
		ComputeRecurrenceFrequencyWeek,
	}
}

// ComputeTriggerType - Is the trigger type recurrence or cron.
type ComputeTriggerType string

const (
	ComputeTriggerTypeCron       ComputeTriggerType = "Cron"
	ComputeTriggerTypeRecurrence ComputeTriggerType = "Recurrence"
)

// PossibleComputeTriggerTypeValues returns the possible values for the ComputeTriggerType const type.
func PossibleComputeTriggerTypeValues() []ComputeTriggerType {
	return []ComputeTriggerType{
		ComputeTriggerTypeCron,
		ComputeTriggerTypeRecurrence,
	}
}

// ComputeType - The type of compute
type ComputeType string

const (
	ComputeTypeAKS               ComputeType = "AKS"
	ComputeTypeAmlCompute        ComputeType = "AmlCompute"
	ComputeTypeComputeInstance   ComputeType = "ComputeInstance"
	ComputeTypeDataFactory       ComputeType = "DataFactory"
	ComputeTypeDataLakeAnalytics ComputeType = "DataLakeAnalytics"
	ComputeTypeDatabricks        ComputeType = "Databricks"
	ComputeTypeHDInsight         ComputeType = "HDInsight"
	ComputeTypeKubernetes        ComputeType = "Kubernetes"
	ComputeTypeSynapseSpark      ComputeType = "SynapseSpark"
	ComputeTypeVirtualMachine    ComputeType = "VirtualMachine"
)

// PossibleComputeTypeValues returns the possible values for the ComputeType const type.
func PossibleComputeTypeValues() []ComputeType {
	return []ComputeType{
		ComputeTypeAKS,
		ComputeTypeAmlCompute,
		ComputeTypeComputeInstance,
		ComputeTypeDataFactory,
		ComputeTypeDataLakeAnalytics,
		ComputeTypeDatabricks,
		ComputeTypeHDInsight,
		ComputeTypeKubernetes,
		ComputeTypeSynapseSpark,
		ComputeTypeVirtualMachine,
	}
}

// ComputeWeekDay - Enum of weekday
type ComputeWeekDay string

const (
	// ComputeWeekDayFriday - Friday weekday
	ComputeWeekDayFriday ComputeWeekDay = "Friday"
	// ComputeWeekDayMonday - Monday weekday
	ComputeWeekDayMonday ComputeWeekDay = "Monday"
	// ComputeWeekDaySaturday - Saturday weekday
	ComputeWeekDaySaturday ComputeWeekDay = "Saturday"
	// ComputeWeekDaySunday - Sunday weekday
	ComputeWeekDaySunday ComputeWeekDay = "Sunday"
	// ComputeWeekDayThursday - Thursday weekday
	ComputeWeekDayThursday ComputeWeekDay = "Thursday"
	// ComputeWeekDayTuesday - Tuesday weekday
	ComputeWeekDayTuesday ComputeWeekDay = "Tuesday"
	// ComputeWeekDayWednesday - Wednesday weekday
	ComputeWeekDayWednesday ComputeWeekDay = "Wednesday"
)

// PossibleComputeWeekDayValues returns the possible values for the ComputeWeekDay const type.
func PossibleComputeWeekDayValues() []ComputeWeekDay {
	return []ComputeWeekDay{
		ComputeWeekDayFriday,
		ComputeWeekDayMonday,
		ComputeWeekDaySaturday,
		ComputeWeekDaySunday,
		ComputeWeekDayThursday,
		ComputeWeekDayTuesday,
		ComputeWeekDayWednesday,
	}
}

// ConnectionAuthType - Authentication type of the connection target
type ConnectionAuthType string

const (
	ConnectionAuthTypeAAD              ConnectionAuthType = "AAD"
	ConnectionAuthTypeAPIKey           ConnectionAuthType = "ApiKey"
	ConnectionAuthTypeAccessKey        ConnectionAuthType = "AccessKey"
	ConnectionAuthTypeAccountKey       ConnectionAuthType = "AccountKey"
	ConnectionAuthTypeCustomKeys       ConnectionAuthType = "CustomKeys"
	ConnectionAuthTypeManagedIdentity  ConnectionAuthType = "ManagedIdentity"
	ConnectionAuthTypeNone             ConnectionAuthType = "None"
	ConnectionAuthTypeOAuth2           ConnectionAuthType = "OAuth2"
	ConnectionAuthTypePAT              ConnectionAuthType = "PAT"
	ConnectionAuthTypeSAS              ConnectionAuthType = "SAS"
	ConnectionAuthTypeServicePrincipal ConnectionAuthType = "ServicePrincipal"
	ConnectionAuthTypeUsernamePassword ConnectionAuthType = "UsernamePassword"
)

// PossibleConnectionAuthTypeValues returns the possible values for the ConnectionAuthType const type.
func PossibleConnectionAuthTypeValues() []ConnectionAuthType {
	return []ConnectionAuthType{
		ConnectionAuthTypeAAD,
		ConnectionAuthTypeAPIKey,
		ConnectionAuthTypeAccessKey,
		ConnectionAuthTypeAccountKey,
		ConnectionAuthTypeCustomKeys,
		ConnectionAuthTypeManagedIdentity,
		ConnectionAuthTypeNone,
		ConnectionAuthTypeOAuth2,
		ConnectionAuthTypePAT,
		ConnectionAuthTypeSAS,
		ConnectionAuthTypeServicePrincipal,
		ConnectionAuthTypeUsernamePassword,
	}
}

// ConnectionCategory - Category of the connection
type ConnectionCategory string

const (
	ConnectionCategoryADLSGen2                 ConnectionCategory = "ADLSGen2"
	ConnectionCategoryAIServices               ConnectionCategory = "AIServices"
	ConnectionCategoryAPIKey                   ConnectionCategory = "ApiKey"
	ConnectionCategoryAmazonMws                ConnectionCategory = "AmazonMws"
	ConnectionCategoryAmazonRdsForOracle       ConnectionCategory = "AmazonRdsForOracle"
	ConnectionCategoryAmazonRdsForSQLServer    ConnectionCategory = "AmazonRdsForSqlServer"
	ConnectionCategoryAmazonRedshift           ConnectionCategory = "AmazonRedshift"
	ConnectionCategoryAmazonS3Compatible       ConnectionCategory = "AmazonS3Compatible"
	ConnectionCategoryAzureBlob                ConnectionCategory = "AzureBlob"
	ConnectionCategoryAzureDataExplorer        ConnectionCategory = "AzureDataExplorer"
	ConnectionCategoryAzureDatabricksDeltaLake ConnectionCategory = "AzureDatabricksDeltaLake"
	ConnectionCategoryAzureMariaDb             ConnectionCategory = "AzureMariaDb"
	ConnectionCategoryAzureMySQLDb             ConnectionCategory = "AzureMySqlDb"
	ConnectionCategoryAzureOneLake             ConnectionCategory = "AzureOneLake"
	ConnectionCategoryAzureOpenAI              ConnectionCategory = "AzureOpenAI"
	ConnectionCategoryAzurePostgresDb          ConnectionCategory = "AzurePostgresDb"
	ConnectionCategoryAzureSQLDb               ConnectionCategory = "AzureSqlDb"
	ConnectionCategoryAzureSQLMi               ConnectionCategory = "AzureSqlMi"
	ConnectionCategoryAzureSynapseAnalytics    ConnectionCategory = "AzureSynapseAnalytics"
	ConnectionCategoryAzureTableStorage        ConnectionCategory = "AzureTableStorage"
	ConnectionCategoryBingLLMSearch            ConnectionCategory = "BingLLMSearch"
	ConnectionCategoryCassandra                ConnectionCategory = "Cassandra"
	ConnectionCategoryCognitiveSearch          ConnectionCategory = "CognitiveSearch"
	ConnectionCategoryCognitiveService         ConnectionCategory = "CognitiveService"
	ConnectionCategoryConcur                   ConnectionCategory = "Concur"
	ConnectionCategoryContainerRegistry        ConnectionCategory = "ContainerRegistry"
	ConnectionCategoryCosmosDb                 ConnectionCategory = "CosmosDb"
	ConnectionCategoryCosmosDbMongoDbAPI       ConnectionCategory = "CosmosDbMongoDbApi"
	ConnectionCategoryCouchbase                ConnectionCategory = "Couchbase"
	ConnectionCategoryCustomKeys               ConnectionCategory = "CustomKeys"
	ConnectionCategoryDb2                      ConnectionCategory = "Db2"
	ConnectionCategoryDrill                    ConnectionCategory = "Drill"
	ConnectionCategoryDynamics                 ConnectionCategory = "Dynamics"
	ConnectionCategoryDynamicsAx               ConnectionCategory = "DynamicsAx"
	ConnectionCategoryDynamicsCrm              ConnectionCategory = "DynamicsCrm"
	ConnectionCategoryEloqua                   ConnectionCategory = "Eloqua"
	ConnectionCategoryFileServer               ConnectionCategory = "FileServer"
	ConnectionCategoryFtpServer                ConnectionCategory = "FtpServer"
	ConnectionCategoryGenericContainerRegistry ConnectionCategory = "GenericContainerRegistry"
	ConnectionCategoryGenericHTTP              ConnectionCategory = "GenericHttp"
	ConnectionCategoryGenericRest              ConnectionCategory = "GenericRest"
	ConnectionCategoryGit                      ConnectionCategory = "Git"
	ConnectionCategoryGoogleAdWords            ConnectionCategory = "GoogleAdWords"
	ConnectionCategoryGoogleBigQuery           ConnectionCategory = "GoogleBigQuery"
	ConnectionCategoryGoogleCloudStorage       ConnectionCategory = "GoogleCloudStorage"
	ConnectionCategoryGreenplum                ConnectionCategory = "Greenplum"
	ConnectionCategoryHbase                    ConnectionCategory = "Hbase"
	ConnectionCategoryHdfs                     ConnectionCategory = "Hdfs"
	ConnectionCategoryHive                     ConnectionCategory = "Hive"
	ConnectionCategoryHubspot                  ConnectionCategory = "Hubspot"
	ConnectionCategoryImpala                   ConnectionCategory = "Impala"
	ConnectionCategoryInformix                 ConnectionCategory = "Informix"
	ConnectionCategoryJira                     ConnectionCategory = "Jira"
	ConnectionCategoryMagento                  ConnectionCategory = "Magento"
	ConnectionCategoryMariaDb                  ConnectionCategory = "MariaDb"
	ConnectionCategoryMarketo                  ConnectionCategory = "Marketo"
	ConnectionCategoryMicrosoftAccess          ConnectionCategory = "MicrosoftAccess"
	ConnectionCategoryMongoDbAtlas             ConnectionCategory = "MongoDbAtlas"
	ConnectionCategoryMongoDbV2                ConnectionCategory = "MongoDbV2"
	ConnectionCategoryMySQL                    ConnectionCategory = "MySql"
	ConnectionCategoryNetezza                  ConnectionCategory = "Netezza"
	ConnectionCategoryODataRest                ConnectionCategory = "ODataRest"
	ConnectionCategoryOdbc                     ConnectionCategory = "Odbc"
	ConnectionCategoryOffice365                ConnectionCategory = "Office365"
	ConnectionCategoryOpenAI                   ConnectionCategory = "OpenAI"
	ConnectionCategoryOracle                   ConnectionCategory = "Oracle"
	ConnectionCategoryOracleCloudStorage       ConnectionCategory = "OracleCloudStorage"
	ConnectionCategoryOracleServiceCloud       ConnectionCategory = "OracleServiceCloud"
	ConnectionCategoryPayPal                   ConnectionCategory = "PayPal"
	ConnectionCategoryPhoenix                  ConnectionCategory = "Phoenix"
	ConnectionCategoryPostgreSQL               ConnectionCategory = "PostgreSql"
	ConnectionCategoryPresto                   ConnectionCategory = "Presto"
	ConnectionCategoryPythonFeed               ConnectionCategory = "PythonFeed"
	ConnectionCategoryQuickBooks               ConnectionCategory = "QuickBooks"
	ConnectionCategoryRedis                    ConnectionCategory = "Redis"
	ConnectionCategoryResponsys                ConnectionCategory = "Responsys"
	ConnectionCategoryS3                       ConnectionCategory = "S3"
	ConnectionCategorySQLServer                ConnectionCategory = "SqlServer"
	ConnectionCategorySalesforce               ConnectionCategory = "Salesforce"
	ConnectionCategorySalesforceMarketingCloud ConnectionCategory = "SalesforceMarketingCloud"
	ConnectionCategorySalesforceServiceCloud   ConnectionCategory = "SalesforceServiceCloud"
	ConnectionCategorySapBw                    ConnectionCategory = "SapBw"
	ConnectionCategorySapCloudForCustomer      ConnectionCategory = "SapCloudForCustomer"
	ConnectionCategorySapEcc                   ConnectionCategory = "SapEcc"
	ConnectionCategorySapHana                  ConnectionCategory = "SapHana"
	ConnectionCategorySapOpenHub               ConnectionCategory = "SapOpenHub"
	ConnectionCategorySapTable                 ConnectionCategory = "SapTable"
	ConnectionCategorySerp                     ConnectionCategory = "Serp"
	ConnectionCategoryServerless               ConnectionCategory = "Serverless"
	ConnectionCategoryServiceNow               ConnectionCategory = "ServiceNow"
	ConnectionCategorySftp                     ConnectionCategory = "Sftp"
	ConnectionCategorySharePointOnlineList     ConnectionCategory = "SharePointOnlineList"
	ConnectionCategoryShopify                  ConnectionCategory = "Shopify"
	ConnectionCategorySnowflake                ConnectionCategory = "Snowflake"
	ConnectionCategorySpark                    ConnectionCategory = "Spark"
	ConnectionCategorySquare                   ConnectionCategory = "Square"
	ConnectionCategorySybase                   ConnectionCategory = "Sybase"
	ConnectionCategoryTeradata                 ConnectionCategory = "Teradata"
	ConnectionCategoryVertica                  ConnectionCategory = "Vertica"
	ConnectionCategoryWebTable                 ConnectionCategory = "WebTable"
	ConnectionCategoryXero                     ConnectionCategory = "Xero"
	ConnectionCategoryZoho                     ConnectionCategory = "Zoho"
)

// PossibleConnectionCategoryValues returns the possible values for the ConnectionCategory const type.
func PossibleConnectionCategoryValues() []ConnectionCategory {
	return []ConnectionCategory{
		ConnectionCategoryADLSGen2,
		ConnectionCategoryAIServices,
		ConnectionCategoryAPIKey,
		ConnectionCategoryAmazonMws,
		ConnectionCategoryAmazonRdsForOracle,
		ConnectionCategoryAmazonRdsForSQLServer,
		ConnectionCategoryAmazonRedshift,
		ConnectionCategoryAmazonS3Compatible,
		ConnectionCategoryAzureBlob,
		ConnectionCategoryAzureDataExplorer,
		ConnectionCategoryAzureDatabricksDeltaLake,
		ConnectionCategoryAzureMariaDb,
		ConnectionCategoryAzureMySQLDb,
		ConnectionCategoryAzureOneLake,
		ConnectionCategoryAzureOpenAI,
		ConnectionCategoryAzurePostgresDb,
		ConnectionCategoryAzureSQLDb,
		ConnectionCategoryAzureSQLMi,
		ConnectionCategoryAzureSynapseAnalytics,
		ConnectionCategoryAzureTableStorage,
		ConnectionCategoryBingLLMSearch,
		ConnectionCategoryCassandra,
		ConnectionCategoryCognitiveSearch,
		ConnectionCategoryCognitiveService,
		ConnectionCategoryConcur,
		ConnectionCategoryContainerRegistry,
		ConnectionCategoryCosmosDb,
		ConnectionCategoryCosmosDbMongoDbAPI,
		ConnectionCategoryCouchbase,
		ConnectionCategoryCustomKeys,
		ConnectionCategoryDb2,
		ConnectionCategoryDrill,
		ConnectionCategoryDynamics,
		ConnectionCategoryDynamicsAx,
		ConnectionCategoryDynamicsCrm,
		ConnectionCategoryEloqua,
		ConnectionCategoryFileServer,
		ConnectionCategoryFtpServer,
		ConnectionCategoryGenericContainerRegistry,
		ConnectionCategoryGenericHTTP,
		ConnectionCategoryGenericRest,
		ConnectionCategoryGit,
		ConnectionCategoryGoogleAdWords,
		ConnectionCategoryGoogleBigQuery,
		ConnectionCategoryGoogleCloudStorage,
		ConnectionCategoryGreenplum,
		ConnectionCategoryHbase,
		ConnectionCategoryHdfs,
		ConnectionCategoryHive,
		ConnectionCategoryHubspot,
		ConnectionCategoryImpala,
		ConnectionCategoryInformix,
		ConnectionCategoryJira,
		ConnectionCategoryMagento,
		ConnectionCategoryMariaDb,
		ConnectionCategoryMarketo,
		ConnectionCategoryMicrosoftAccess,
		ConnectionCategoryMongoDbAtlas,
		ConnectionCategoryMongoDbV2,
		ConnectionCategoryMySQL,
		ConnectionCategoryNetezza,
		ConnectionCategoryODataRest,
		ConnectionCategoryOdbc,
		ConnectionCategoryOffice365,
		ConnectionCategoryOpenAI,
		ConnectionCategoryOracle,
		ConnectionCategoryOracleCloudStorage,
		ConnectionCategoryOracleServiceCloud,
		ConnectionCategoryPayPal,
		ConnectionCategoryPhoenix,
		ConnectionCategoryPostgreSQL,
		ConnectionCategoryPresto,
		ConnectionCategoryPythonFeed,
		ConnectionCategoryQuickBooks,
		ConnectionCategoryRedis,
		ConnectionCategoryResponsys,
		ConnectionCategoryS3,
		ConnectionCategorySQLServer,
		ConnectionCategorySalesforce,
		ConnectionCategorySalesforceMarketingCloud,
		ConnectionCategorySalesforceServiceCloud,
		ConnectionCategorySapBw,
		ConnectionCategorySapCloudForCustomer,
		ConnectionCategorySapEcc,
		ConnectionCategorySapHana,
		ConnectionCategorySapOpenHub,
		ConnectionCategorySapTable,
		ConnectionCategorySerp,
		ConnectionCategoryServerless,
		ConnectionCategoryServiceNow,
		ConnectionCategorySftp,
		ConnectionCategorySharePointOnlineList,
		ConnectionCategoryShopify,
		ConnectionCategorySnowflake,
		ConnectionCategorySpark,
		ConnectionCategorySquare,
		ConnectionCategorySybase,
		ConnectionCategoryTeradata,
		ConnectionCategoryVertica,
		ConnectionCategoryWebTable,
		ConnectionCategoryXero,
		ConnectionCategoryZoho,
	}
}

// ConnectionGroup - Group based on connection category
type ConnectionGroup string

const (
	ConnectionGroupAzure           ConnectionGroup = "Azure"
	ConnectionGroupAzureAI         ConnectionGroup = "AzureAI"
	ConnectionGroupDatabase        ConnectionGroup = "Database"
	ConnectionGroupFile            ConnectionGroup = "File"
	ConnectionGroupGenericProtocol ConnectionGroup = "GenericProtocol"
	ConnectionGroupNoSQL           ConnectionGroup = "NoSQL"
	ConnectionGroupServicesAndApps ConnectionGroup = "ServicesAndApps"
)

// PossibleConnectionGroupValues returns the possible values for the ConnectionGroup const type.
func PossibleConnectionGroupValues() []ConnectionGroup {
	return []ConnectionGroup{
		ConnectionGroupAzure,
		ConnectionGroupAzureAI,
		ConnectionGroupDatabase,
		ConnectionGroupFile,
		ConnectionGroupGenericProtocol,
		ConnectionGroupNoSQL,
		ConnectionGroupServicesAndApps,
	}
}

type ContainerType string

const (
	ContainerTypeInferenceServer    ContainerType = "InferenceServer"
	ContainerTypeStorageInitializer ContainerType = "StorageInitializer"
)

// PossibleContainerTypeValues returns the possible values for the ContainerType const type.
func PossibleContainerTypeValues() []ContainerType {
	return []ContainerType{
		ContainerTypeInferenceServer,
		ContainerTypeStorageInitializer,
	}
}

// ContentSafetyStatus - Specifies the status of content safety.
type ContentSafetyStatus string

const (
	ContentSafetyStatusDisabled ContentSafetyStatus = "Disabled"
	ContentSafetyStatusEnabled  ContentSafetyStatus = "Enabled"
)

// PossibleContentSafetyStatusValues returns the possible values for the ContentSafetyStatus const type.
func PossibleContentSafetyStatusValues() []ContentSafetyStatus {
	return []ContentSafetyStatus{
		ContentSafetyStatusDisabled,
		ContentSafetyStatusEnabled,
	}
}

// CreatedByType - The type of identity that created the resource.
type CreatedByType string

const (
	CreatedByTypeApplication     CreatedByType = "Application"
	CreatedByTypeKey             CreatedByType = "Key"
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	CreatedByTypeUser            CreatedByType = "User"
)

// PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.
func PossibleCreatedByTypeValues() []CreatedByType {
	return []CreatedByType{
		CreatedByTypeApplication,
		CreatedByTypeKey,
		CreatedByTypeManagedIdentity,
		CreatedByTypeUser,
	}
}

// CredentialsType - Enum to determine the datastore credentials type.
type CredentialsType string

const (
	CredentialsTypeAccountKey       CredentialsType = "AccountKey"
	CredentialsTypeCertificate      CredentialsType = "Certificate"
	CredentialsTypeNone             CredentialsType = "None"
	CredentialsTypeSas              CredentialsType = "Sas"
	CredentialsTypeServicePrincipal CredentialsType = "ServicePrincipal"
)

// PossibleCredentialsTypeValues returns the possible values for the CredentialsType const type.
func PossibleCredentialsTypeValues() []CredentialsType {
	return []CredentialsType{
		CredentialsTypeAccountKey,
		CredentialsTypeCertificate,
		CredentialsTypeNone,
		CredentialsTypeSas,
		CredentialsTypeServicePrincipal,
	}
}

type DataAvailabilityStatus string

const (
	DataAvailabilityStatusComplete   DataAvailabilityStatus = "Complete"
	DataAvailabilityStatusIncomplete DataAvailabilityStatus = "Incomplete"
	DataAvailabilityStatusNone       DataAvailabilityStatus = "None"
	DataAvailabilityStatusPending    DataAvailabilityStatus = "Pending"
)

// PossibleDataAvailabilityStatusValues returns the possible values for the DataAvailabilityStatus const type.
func PossibleDataAvailabilityStatusValues() []DataAvailabilityStatus {
	return []DataAvailabilityStatus{
		DataAvailabilityStatusComplete,
		DataAvailabilityStatusIncomplete,
		DataAvailabilityStatusNone,
		DataAvailabilityStatusPending,
	}
}

type DataCollectionMode string

const (
	DataCollectionModeDisabled DataCollectionMode = "Disabled"
	DataCollectionModeEnabled  DataCollectionMode = "Enabled"
)

// PossibleDataCollectionModeValues returns the possible values for the DataCollectionMode const type.
func PossibleDataCollectionModeValues() []DataCollectionMode {
	return []DataCollectionMode{
		DataCollectionModeDisabled,
		DataCollectionModeEnabled,
	}
}

// DataReferenceCredentialType - Enum to determine the DataReference credentials type.
type DataReferenceCredentialType string

const (
	DataReferenceCredentialTypeDockerCredentials DataReferenceCredentialType = "DockerCredentials"
	DataReferenceCredentialTypeManagedIdentity   DataReferenceCredentialType = "ManagedIdentity"
	DataReferenceCredentialTypeNoCredentials     DataReferenceCredentialType = "NoCredentials"
	DataReferenceCredentialTypeSAS               DataReferenceCredentialType = "SAS"
)

// PossibleDataReferenceCredentialTypeValues returns the possible values for the DataReferenceCredentialType const type.
func PossibleDataReferenceCredentialTypeValues() []DataReferenceCredentialType {
	return []DataReferenceCredentialType{
		DataReferenceCredentialTypeDockerCredentials,
		DataReferenceCredentialTypeManagedIdentity,
		DataReferenceCredentialTypeNoCredentials,
		DataReferenceCredentialTypeSAS,
	}
}

// DataType - Enum to determine the type of data.
type DataType string

const (
	DataTypeMltable   DataType = "mltable"
	DataTypeURIFile   DataType = "uri_file"
	DataTypeURIFolder DataType = "uri_folder"
)

// PossibleDataTypeValues returns the possible values for the DataType const type.
func PossibleDataTypeValues() []DataType {
	return []DataType{
		DataTypeMltable,
		DataTypeURIFile,
		DataTypeURIFolder,
	}
}

// DatastoreType - Enum to determine the datastore contents type.
type DatastoreType string

const (
	DatastoreTypeAzureBlob         DatastoreType = "AzureBlob"
	DatastoreTypeAzureDataLakeGen1 DatastoreType = "AzureDataLakeGen1"
	DatastoreTypeAzureDataLakeGen2 DatastoreType = "AzureDataLakeGen2"
	DatastoreTypeAzureFile         DatastoreType = "AzureFile"
	DatastoreTypeOneLake           DatastoreType = "OneLake"
)

// PossibleDatastoreTypeValues returns the possible values for the DatastoreType const type.
func PossibleDatastoreTypeValues() []DatastoreType {
	return []DatastoreType{
		DatastoreTypeAzureBlob,
		DatastoreTypeAzureDataLakeGen1,
		DatastoreTypeAzureDataLakeGen2,
		DatastoreTypeAzureFile,
		DatastoreTypeOneLake,
	}
}

// DeploymentProvisioningState - Possible values for DeploymentProvisioningState.
type DeploymentProvisioningState string

const (
	DeploymentProvisioningStateCanceled  DeploymentProvisioningState = "Canceled"
	DeploymentProvisioningStateCreating  DeploymentProvisioningState = "Creating"
	DeploymentProvisioningStateDeleting  DeploymentProvisioningState = "Deleting"
	DeploymentProvisioningStateFailed    DeploymentProvisioningState = "Failed"
	DeploymentProvisioningStateScaling   DeploymentProvisioningState = "Scaling"
	DeploymentProvisioningStateSucceeded DeploymentProvisioningState = "Succeeded"
	DeploymentProvisioningStateUpdating  DeploymentProvisioningState = "Updating"
)

// PossibleDeploymentProvisioningStateValues returns the possible values for the DeploymentProvisioningState const type.
func PossibleDeploymentProvisioningStateValues() []DeploymentProvisioningState {
	return []DeploymentProvisioningState{
		DeploymentProvisioningStateCanceled,
		DeploymentProvisioningStateCreating,
		DeploymentProvisioningStateDeleting,
		DeploymentProvisioningStateFailed,
		DeploymentProvisioningStateScaling,
		DeploymentProvisioningStateSucceeded,
		DeploymentProvisioningStateUpdating,
	}
}

// DiagnoseResultLevel - Level of workspace setup error
type DiagnoseResultLevel string

const (
	DiagnoseResultLevelError       DiagnoseResultLevel = "Error"
	DiagnoseResultLevelInformation DiagnoseResultLevel = "Information"
	DiagnoseResultLevelWarning     DiagnoseResultLevel = "Warning"
)

// PossibleDiagnoseResultLevelValues returns the possible values for the DiagnoseResultLevel const type.
func PossibleDiagnoseResultLevelValues() []DiagnoseResultLevel {
	return []DiagnoseResultLevel{
		DiagnoseResultLevelError,
		DiagnoseResultLevelInformation,
		DiagnoseResultLevelWarning,
	}
}

// DistributionType - Enum to determine the job distribution type.
type DistributionType string

const (
	DistributionTypeMpi        DistributionType = "Mpi"
	DistributionTypePyTorch    DistributionType = "PyTorch"
	DistributionTypeTensorFlow DistributionType = "TensorFlow"
)

// PossibleDistributionTypeValues returns the possible values for the DistributionType const type.
func PossibleDistributionTypeValues() []DistributionType {
	return []DistributionType{
		DistributionTypeMpi,
		DistributionTypePyTorch,
		DistributionTypeTensorFlow,
	}
}

type EarlyTerminationPolicyType string

const (
	EarlyTerminationPolicyTypeBandit              EarlyTerminationPolicyType = "Bandit"
	EarlyTerminationPolicyTypeMedianStopping      EarlyTerminationPolicyType = "MedianStopping"
	EarlyTerminationPolicyTypeTruncationSelection EarlyTerminationPolicyType = "TruncationSelection"
)

// PossibleEarlyTerminationPolicyTypeValues returns the possible values for the EarlyTerminationPolicyType const type.
func PossibleEarlyTerminationPolicyTypeValues() []EarlyTerminationPolicyType {
	return []EarlyTerminationPolicyType{
		EarlyTerminationPolicyTypeBandit,
		EarlyTerminationPolicyTypeMedianStopping,
		EarlyTerminationPolicyTypeTruncationSelection,
	}
}

// EgressPublicNetworkAccessType - Enum to determine whether PublicNetworkAccess is Enabled or Disabled for egress of a deployment.
type EgressPublicNetworkAccessType string

const (
	EgressPublicNetworkAccessTypeDisabled EgressPublicNetworkAccessType = "Disabled"
	EgressPublicNetworkAccessTypeEnabled  EgressPublicNetworkAccessType = "Enabled"
)

// PossibleEgressPublicNetworkAccessTypeValues returns the possible values for the EgressPublicNetworkAccessType const type.
func PossibleEgressPublicNetworkAccessTypeValues() []EgressPublicNetworkAccessType {
	return []EgressPublicNetworkAccessType{
		EgressPublicNetworkAccessTypeDisabled,
		EgressPublicNetworkAccessTypeEnabled,
	}
}

// EmailNotificationEnableType - Enum to determine the email notification type.
type EmailNotificationEnableType string

const (
	EmailNotificationEnableTypeJobCancelled EmailNotificationEnableType = "JobCancelled"
	EmailNotificationEnableTypeJobCompleted EmailNotificationEnableType = "JobCompleted"
	EmailNotificationEnableTypeJobFailed    EmailNotificationEnableType = "JobFailed"
)

// PossibleEmailNotificationEnableTypeValues returns the possible values for the EmailNotificationEnableType const type.
func PossibleEmailNotificationEnableTypeValues() []EmailNotificationEnableType {
	return []EmailNotificationEnableType{
		EmailNotificationEnableTypeJobCancelled,
		EmailNotificationEnableTypeJobCompleted,
		EmailNotificationEnableTypeJobFailed,
	}
}

// EncryptionStatus - Indicates whether or not the encryption is enabled for the workspace.
type EncryptionStatus string

const (
	EncryptionStatusDisabled EncryptionStatus = "Disabled"
	EncryptionStatusEnabled  EncryptionStatus = "Enabled"
)

// PossibleEncryptionStatusValues returns the possible values for the EncryptionStatus const type.
func PossibleEncryptionStatusValues() []EncryptionStatus {
	return []EncryptionStatus{
		EncryptionStatusDisabled,
		EncryptionStatusEnabled,
	}
}

// EndpointAuthMode - Enum to determine endpoint authentication mode.
type EndpointAuthMode string

const (
	EndpointAuthModeAADToken EndpointAuthMode = "AADToken"
	EndpointAuthModeAMLToken EndpointAuthMode = "AMLToken"
	EndpointAuthModeKey      EndpointAuthMode = "Key"
)

// PossibleEndpointAuthModeValues returns the possible values for the EndpointAuthMode const type.
func PossibleEndpointAuthModeValues() []EndpointAuthMode {
	return []EndpointAuthMode{
		EndpointAuthModeAADToken,
		EndpointAuthModeAMLToken,
		EndpointAuthModeKey,
	}
}

// EndpointComputeType - Enum to determine endpoint compute type.
type EndpointComputeType string

const (
	EndpointComputeTypeAzureMLCompute EndpointComputeType = "AzureMLCompute"
	EndpointComputeTypeKubernetes     EndpointComputeType = "Kubernetes"
	EndpointComputeTypeManaged        EndpointComputeType = "Managed"
)

// PossibleEndpointComputeTypeValues returns the possible values for the EndpointComputeType const type.
func PossibleEndpointComputeTypeValues() []EndpointComputeType {
	return []EndpointComputeType{
		EndpointComputeTypeAzureMLCompute,
		EndpointComputeTypeKubernetes,
		EndpointComputeTypeManaged,
	}
}

// EndpointProvisioningState - State of endpoint provisioning.
type EndpointProvisioningState string

const (
	EndpointProvisioningStateCanceled  EndpointProvisioningState = "Canceled"
	EndpointProvisioningStateCreating  EndpointProvisioningState = "Creating"
	EndpointProvisioningStateDeleting  EndpointProvisioningState = "Deleting"
	EndpointProvisioningStateFailed    EndpointProvisioningState = "Failed"
	EndpointProvisioningStateSucceeded EndpointProvisioningState = "Succeeded"
	EndpointProvisioningStateUpdating  EndpointProvisioningState = "Updating"
)

// PossibleEndpointProvisioningStateValues returns the possible values for the EndpointProvisioningState const type.
func PossibleEndpointProvisioningStateValues() []EndpointProvisioningState {
	return []EndpointProvisioningState{
		EndpointProvisioningStateCanceled,
		EndpointProvisioningStateCreating,
		EndpointProvisioningStateDeleting,
		EndpointProvisioningStateFailed,
		EndpointProvisioningStateSucceeded,
		EndpointProvisioningStateUpdating,
	}
}

// EndpointServiceConnectionStatus - Connection status of the service consumer with the service provider
type EndpointServiceConnectionStatus string

const (
	EndpointServiceConnectionStatusApproved     EndpointServiceConnectionStatus = "Approved"
	EndpointServiceConnectionStatusDisconnected EndpointServiceConnectionStatus = "Disconnected"
	EndpointServiceConnectionStatusPending      EndpointServiceConnectionStatus = "Pending"
	EndpointServiceConnectionStatusRejected     EndpointServiceConnectionStatus = "Rejected"
)

// PossibleEndpointServiceConnectionStatusValues returns the possible values for the EndpointServiceConnectionStatus const type.
func PossibleEndpointServiceConnectionStatusValues() []EndpointServiceConnectionStatus {
	return []EndpointServiceConnectionStatus{
		EndpointServiceConnectionStatusApproved,
		EndpointServiceConnectionStatusDisconnected,
		EndpointServiceConnectionStatusPending,
		EndpointServiceConnectionStatusRejected,
	}
}

// EnvironmentType - Environment type is either user created or curated by Azure ML service
type EnvironmentType string

const (
	EnvironmentTypeCurated     EnvironmentType = "Curated"
	EnvironmentTypeUserCreated EnvironmentType = "UserCreated"
)

// PossibleEnvironmentTypeValues returns the possible values for the EnvironmentType const type.
func PossibleEnvironmentTypeValues() []EnvironmentType {
	return []EnvironmentType{
		EnvironmentTypeCurated,
		EnvironmentTypeUserCreated,
	}
}

// EnvironmentVariableType - Type of the Environment Variable. Possible values are: local - For local variable
type EnvironmentVariableType string

const (
	EnvironmentVariableTypeLocal EnvironmentVariableType = "local"
)

// PossibleEnvironmentVariableTypeValues returns the possible values for the EnvironmentVariableType const type.
func PossibleEnvironmentVariableTypeValues() []EnvironmentVariableType {
	return []EnvironmentVariableType{
		EnvironmentVariableTypeLocal,
	}
}

type FeatureAttributionMetric string

const (
	// FeatureAttributionMetricNormalizedDiscountedCumulativeGain - The Normalized Discounted Cumulative Gain metric.
	FeatureAttributionMetricNormalizedDiscountedCumulativeGain FeatureAttributionMetric = "NormalizedDiscountedCumulativeGain"
)

// PossibleFeatureAttributionMetricValues returns the possible values for the FeatureAttributionMetric const type.
func PossibleFeatureAttributionMetricValues() []FeatureAttributionMetric {
	return []FeatureAttributionMetric{
		FeatureAttributionMetricNormalizedDiscountedCumulativeGain,
	}
}

type FeatureDataType string

const (
	FeatureDataTypeBinary   FeatureDataType = "Binary"
	FeatureDataTypeBoolean  FeatureDataType = "Boolean"
	FeatureDataTypeDatetime FeatureDataType = "Datetime"
	FeatureDataTypeDouble   FeatureDataType = "Double"
	FeatureDataTypeFloat    FeatureDataType = "Float"
	FeatureDataTypeInteger  FeatureDataType = "Integer"
	FeatureDataTypeLong     FeatureDataType = "Long"
	FeatureDataTypeString   FeatureDataType = "String"
)

// PossibleFeatureDataTypeValues returns the possible values for the FeatureDataType const type.
func PossibleFeatureDataTypeValues() []FeatureDataType {
	return []FeatureDataType{
		FeatureDataTypeBinary,
		FeatureDataTypeBoolean,
		FeatureDataTypeDatetime,
		FeatureDataTypeDouble,
		FeatureDataTypeFloat,
		FeatureDataTypeInteger,
		FeatureDataTypeLong,
		FeatureDataTypeString,
	}
}

// FeatureImportanceMode - The mode of operation for computing feature importance.
type FeatureImportanceMode string

const (
	// FeatureImportanceModeDisabled - Disables computing feature importance within a signal.
	FeatureImportanceModeDisabled FeatureImportanceMode = "Disabled"
	// FeatureImportanceModeEnabled - Enables computing feature importance within a signal.
	FeatureImportanceModeEnabled FeatureImportanceMode = "Enabled"
)

// PossibleFeatureImportanceModeValues returns the possible values for the FeatureImportanceMode const type.
func PossibleFeatureImportanceModeValues() []FeatureImportanceMode {
	return []FeatureImportanceMode{
		FeatureImportanceModeDisabled,
		FeatureImportanceModeEnabled,
	}
}

// FeatureLags - Flag for generating lags for the numeric features.
type FeatureLags string

const (
	// FeatureLagsAuto - System auto-generates feature lags.
	FeatureLagsAuto FeatureLags = "Auto"
	// FeatureLagsNone - No feature lags generated.
	FeatureLagsNone FeatureLags = "None"
)

// PossibleFeatureLagsValues returns the possible values for the FeatureLags const type.
func PossibleFeatureLagsValues() []FeatureLags {
	return []FeatureLags{
		FeatureLagsAuto,
		FeatureLagsNone,
	}
}

// FeaturizationMode - Featurization mode - determines data featurization mode.
type FeaturizationMode string

const (
	// FeaturizationModeAuto - Auto mode, system performs featurization without any custom featurization inputs.
	FeaturizationModeAuto FeaturizationMode = "Auto"
	// FeaturizationModeCustom - Custom featurization.
	FeaturizationModeCustom FeaturizationMode = "Custom"
	// FeaturizationModeOff - Featurization off. 'Forecasting' task cannot use this value.
	FeaturizationModeOff FeaturizationMode = "Off"
)

// PossibleFeaturizationModeValues returns the possible values for the FeaturizationMode const type.
func PossibleFeaturizationModeValues() []FeaturizationMode {
	return []FeaturizationMode{
		FeaturizationModeAuto,
		FeaturizationModeCustom,
		FeaturizationModeOff,
	}
}

// ForecastHorizonMode - Enum to determine forecast horizon selection mode.
type ForecastHorizonMode string

const (
	// ForecastHorizonModeAuto - Forecast horizon to be determined automatically.
	ForecastHorizonModeAuto ForecastHorizonMode = "Auto"
	// ForecastHorizonModeCustom - Use the custom forecast horizon.
	ForecastHorizonModeCustom ForecastHorizonMode = "Custom"
)

// PossibleForecastHorizonModeValues returns the possible values for the ForecastHorizonMode const type.
func PossibleForecastHorizonModeValues() []ForecastHorizonMode {
	return []ForecastHorizonMode{
		ForecastHorizonModeAuto,
		ForecastHorizonModeCustom,
	}
}

// ForecastingModels - Enum for all forecasting models supported by AutoML.
type ForecastingModels string

const (
	// ForecastingModelsArimax - An Autoregressive Integrated Moving Average with Explanatory Variable (ARIMAX) model can be viewed
	// as a multiple regression model with one or more autoregressive (AR) terms and/or one or more moving average (MA) terms.
	// This method is suitable for forecasting when data is stationary/non stationary, and multivariate with any type of data
	// pattern, i.e., level/trend /seasonality/cyclicity.
	ForecastingModelsArimax ForecastingModels = "Arimax"
	// ForecastingModelsAutoArima - Auto-Autoregressive Integrated Moving Average (ARIMA) model uses time-series data and statistical
	// analysis to interpret the data and make future predictions.
	// This model aims to explain data by using time series data on its past values and uses linear regression to make predictions.
	ForecastingModelsAutoArima ForecastingModels = "AutoArima"
	// ForecastingModelsAverage - The Average forecasting model makes predictions by carrying forward the average of the target
	// values for each time-series in the training data.
	ForecastingModelsAverage ForecastingModels = "Average"
	// ForecastingModelsDecisionTree - Decision Trees are a non-parametric supervised learning method used for both classification
	// and regression tasks.
	// The goal is to create a model that predicts the value of a target variable by learning simple decision rules inferred from
	// the data features.
	ForecastingModelsDecisionTree ForecastingModels = "DecisionTree"
	// ForecastingModelsElasticNet - Elastic net is a popular type of regularized linear regression that combines two popular
	// penalties, specifically the L1 and L2 penalty functions.
	ForecastingModelsElasticNet ForecastingModels = "ElasticNet"
	// ForecastingModelsExponentialSmoothing - Exponential smoothing is a time series forecasting method for univariate data that
	// can be extended to support data with a systematic trend or seasonal component.
	ForecastingModelsExponentialSmoothing ForecastingModels = "ExponentialSmoothing"
	// ForecastingModelsExtremeRandomTrees - Extreme Trees is an ensemble machine learning algorithm that combines the predictions
	// from many decision trees. It is related to the widely used random forest algorithm.
	ForecastingModelsExtremeRandomTrees ForecastingModels = "ExtremeRandomTrees"
	// ForecastingModelsGradientBoosting - The technique of transiting week learners into a strong learner is called Boosting.
	// The gradient boosting algorithm process works on this theory of execution.
	ForecastingModelsGradientBoosting ForecastingModels = "GradientBoosting"
	// ForecastingModelsKNN - K-nearest neighbors (KNN) algorithm uses 'feature similarity' to predict the values of new datapoints
	// which further means that the new data point will be assigned a value based on how closely it matches the points in the
	// training set.
	ForecastingModelsKNN ForecastingModels = "KNN"
	// ForecastingModelsLassoLars - Lasso model fit with Least Angle Regression a.k.a. Lars. It is a Linear Model trained with
	// an L1 prior as regularizer.
	ForecastingModelsLassoLars ForecastingModels = "LassoLars"
	// ForecastingModelsLightGBM - LightGBM is a gradient boosting framework that uses tree based learning algorithms.
	ForecastingModelsLightGBM ForecastingModels = "LightGBM"
	// ForecastingModelsNaive - The Naive forecasting model makes predictions by carrying forward the latest target value for
	// each time-series in the training data.
	ForecastingModelsNaive ForecastingModels = "Naive"
	// ForecastingModelsProphet - Prophet is a procedure for forecasting time series data based on an additive model where non-linear
	// trends are fit with yearly, weekly, and daily seasonality, plus holiday effects.
	// It works best with time series that have strong seasonal effects and several seasons of historical data. Prophet is robust
	// to missing data and shifts in the trend, and typically handles outliers well.
	ForecastingModelsProphet ForecastingModels = "Prophet"
	// ForecastingModelsRandomForest - Random forest is a supervised learning algorithm.
	// The "forest" it builds, is an ensemble of decision trees, usually trained with the “bagging” method.
	// The general idea of the bagging method is that a combination of learning models increases the overall result.
	ForecastingModelsRandomForest ForecastingModels = "RandomForest"
	// ForecastingModelsSGD - SGD: Stochastic gradient descent is an optimization algorithm often used in machine learning applications
	// to find the model parameters that correspond to the best fit between predicted and actual outputs.
	// It's an inexact but powerful technique.
	ForecastingModelsSGD ForecastingModels = "SGD"
	// ForecastingModelsSeasonalAverage - The Seasonal Average forecasting model makes predictions by carrying forward the average
	// value of the latest season of data for each time-series in the training data.
	ForecastingModelsSeasonalAverage ForecastingModels = "SeasonalAverage"
	// ForecastingModelsSeasonalNaive - The Seasonal Naive forecasting model makes predictions by carrying forward the latest
	// season of target values for each time-series in the training data.
	ForecastingModelsSeasonalNaive ForecastingModels = "SeasonalNaive"
	// ForecastingModelsTCNForecaster - TCNForecaster: Temporal Convolutional Networks Forecaster. //TODO: Ask forecasting team
	// for brief intro.
	ForecastingModelsTCNForecaster ForecastingModels = "TCNForecaster"
	// ForecastingModelsXGBoostRegressor - XGBoostRegressor: Extreme Gradient Boosting Regressor is a supervised machine learning
	// model using ensemble of base learners.
	ForecastingModelsXGBoostRegressor ForecastingModels = "XGBoostRegressor"
)

// PossibleForecastingModelsValues returns the possible values for the ForecastingModels const type.
func PossibleForecastingModelsValues() []ForecastingModels {
	return []ForecastingModels{
		ForecastingModelsArimax,
		ForecastingModelsAutoArima,
		ForecastingModelsAverage,
		ForecastingModelsDecisionTree,
		ForecastingModelsElasticNet,
		ForecastingModelsExponentialSmoothing,
		ForecastingModelsExtremeRandomTrees,
		ForecastingModelsGradientBoosting,
		ForecastingModelsKNN,
		ForecastingModelsLassoLars,
		ForecastingModelsLightGBM,
		ForecastingModelsNaive,
		ForecastingModelsProphet,
		ForecastingModelsRandomForest,
		ForecastingModelsSGD,
		ForecastingModelsSeasonalAverage,
		ForecastingModelsSeasonalNaive,
		ForecastingModelsTCNForecaster,
		ForecastingModelsXGBoostRegressor,
	}
}

// ForecastingPrimaryMetrics - Primary metrics for Forecasting task.
type ForecastingPrimaryMetrics string

const (
	// ForecastingPrimaryMetricsNormalizedMeanAbsoluteError - The Normalized Mean Absolute Error (NMAE) is a validation metric
	// to compare the Mean Absolute Error (MAE) of (time) series with different scales.
	ForecastingPrimaryMetricsNormalizedMeanAbsoluteError ForecastingPrimaryMetrics = "NormalizedMeanAbsoluteError"
	// ForecastingPrimaryMetricsNormalizedRootMeanSquaredError - The Normalized Root Mean Squared Error (NRMSE) the RMSE facilitates
	// the comparison between models with different scales.
	ForecastingPrimaryMetricsNormalizedRootMeanSquaredError ForecastingPrimaryMetrics = "NormalizedRootMeanSquaredError"
	// ForecastingPrimaryMetricsR2Score - The R2 score is one of the performance evaluation measures for forecasting-based machine
	// learning models.
	ForecastingPrimaryMetricsR2Score ForecastingPrimaryMetrics = "R2Score"
	// ForecastingPrimaryMetricsSpearmanCorrelation - The Spearman's rank coefficient of correlation is a non-parametric measure
	// of rank correlation.
	ForecastingPrimaryMetricsSpearmanCorrelation ForecastingPrimaryMetrics = "SpearmanCorrelation"
)

// PossibleForecastingPrimaryMetricsValues returns the possible values for the ForecastingPrimaryMetrics const type.
func PossibleForecastingPrimaryMetricsValues() []ForecastingPrimaryMetrics {
	return []ForecastingPrimaryMetrics{
		ForecastingPrimaryMetricsNormalizedMeanAbsoluteError,
		ForecastingPrimaryMetricsNormalizedRootMeanSquaredError,
		ForecastingPrimaryMetricsR2Score,
		ForecastingPrimaryMetricsSpearmanCorrelation,
	}
}

// Goal - Defines supported metric goals for hyperparameter tuning
type Goal string

const (
	GoalMaximize Goal = "Maximize"
	GoalMinimize Goal = "Minimize"
)

// PossibleGoalValues returns the possible values for the Goal const type.
func PossibleGoalValues() []Goal {
	return []Goal{
		GoalMaximize,
		GoalMinimize,
	}
}

// IdentityConfigurationType - Enum to determine identity framework.
type IdentityConfigurationType string

const (
	IdentityConfigurationTypeAMLToken     IdentityConfigurationType = "AMLToken"
	IdentityConfigurationTypeManaged      IdentityConfigurationType = "Managed"
	IdentityConfigurationTypeUserIdentity IdentityConfigurationType = "UserIdentity"
)

// PossibleIdentityConfigurationTypeValues returns the possible values for the IdentityConfigurationType const type.
func PossibleIdentityConfigurationTypeValues() []IdentityConfigurationType {
	return []IdentityConfigurationType{
		IdentityConfigurationTypeAMLToken,
		IdentityConfigurationTypeManaged,
		IdentityConfigurationTypeUserIdentity,
	}
}

// ImageType - Type of the image. Possible values are: docker - For docker images. azureml - For AzureML images
type ImageType string

const (
	ImageTypeAzureml ImageType = "azureml"
	ImageTypeDocker  ImageType = "docker"
)

// PossibleImageTypeValues returns the possible values for the ImageType const type.
func PossibleImageTypeValues() []ImageType {
	return []ImageType{
		ImageTypeAzureml,
		ImageTypeDocker,
	}
}

// InputDeliveryMode - Enum to determine the input data delivery mode.
type InputDeliveryMode string

const (
	InputDeliveryModeDirect         InputDeliveryMode = "Direct"
	InputDeliveryModeDownload       InputDeliveryMode = "Download"
	InputDeliveryModeEvalDownload   InputDeliveryMode = "EvalDownload"
	InputDeliveryModeEvalMount      InputDeliveryMode = "EvalMount"
	InputDeliveryModeReadOnlyMount  InputDeliveryMode = "ReadOnlyMount"
	InputDeliveryModeReadWriteMount InputDeliveryMode = "ReadWriteMount"
)

// PossibleInputDeliveryModeValues returns the possible values for the InputDeliveryMode const type.
func PossibleInputDeliveryModeValues() []InputDeliveryMode {
	return []InputDeliveryMode{
		InputDeliveryModeDirect,
		InputDeliveryModeDownload,
		InputDeliveryModeEvalDownload,
		InputDeliveryModeEvalMount,
		InputDeliveryModeReadOnlyMount,
		InputDeliveryModeReadWriteMount,
	}
}

// InstanceSegmentationPrimaryMetrics - Primary metrics for InstanceSegmentation tasks.
type InstanceSegmentationPrimaryMetrics string

const (
	// InstanceSegmentationPrimaryMetricsMeanAveragePrecision - Mean Average Precision (MAP) is the average of AP (Average Precision).
	// AP is calculated for each class and averaged to get the MAP.
	InstanceSegmentationPrimaryMetricsMeanAveragePrecision InstanceSegmentationPrimaryMetrics = "MeanAveragePrecision"
)

// PossibleInstanceSegmentationPrimaryMetricsValues returns the possible values for the InstanceSegmentationPrimaryMetrics const type.
func PossibleInstanceSegmentationPrimaryMetricsValues() []InstanceSegmentationPrimaryMetrics {
	return []InstanceSegmentationPrimaryMetrics{
		InstanceSegmentationPrimaryMetricsMeanAveragePrecision,
	}
}

// IsolationMode - Isolation mode for the managed network of a machine learning workspace.
type IsolationMode string

const (
	IsolationModeAllowInternetOutbound     IsolationMode = "AllowInternetOutbound"
	IsolationModeAllowOnlyApprovedOutbound IsolationMode = "AllowOnlyApprovedOutbound"
	IsolationModeDisabled                  IsolationMode = "Disabled"
)

// PossibleIsolationModeValues returns the possible values for the IsolationMode const type.
func PossibleIsolationModeValues() []IsolationMode {
	return []IsolationMode{
		IsolationModeAllowInternetOutbound,
		IsolationModeAllowOnlyApprovedOutbound,
		IsolationModeDisabled,
	}
}

// JobInputType - Enum to determine the Job Input Type.
type JobInputType string

const (
	JobInputTypeCustomModel JobInputType = "custom_model"
	JobInputTypeLiteral     JobInputType = "literal"
	JobInputTypeMlflowModel JobInputType = "mlflow_model"
	JobInputTypeMltable     JobInputType = "mltable"
	JobInputTypeTritonModel JobInputType = "triton_model"
	JobInputTypeURIFile     JobInputType = "uri_file"
	JobInputTypeURIFolder   JobInputType = "uri_folder"
)

// PossibleJobInputTypeValues returns the possible values for the JobInputType const type.
func PossibleJobInputTypeValues() []JobInputType {
	return []JobInputType{
		JobInputTypeCustomModel,
		JobInputTypeLiteral,
		JobInputTypeMlflowModel,
		JobInputTypeMltable,
		JobInputTypeTritonModel,
		JobInputTypeURIFile,
		JobInputTypeURIFolder,
	}
}

type JobLimitsType string

const (
	JobLimitsTypeCommand JobLimitsType = "Command"
	JobLimitsTypeSweep   JobLimitsType = "Sweep"
)

// PossibleJobLimitsTypeValues returns the possible values for the JobLimitsType const type.
func PossibleJobLimitsTypeValues() []JobLimitsType {
	return []JobLimitsType{
		JobLimitsTypeCommand,
		JobLimitsTypeSweep,
	}
}

// JobOutputType - Enum to determine the Job Output Type.
type JobOutputType string

const (
	JobOutputTypeCustomModel JobOutputType = "custom_model"
	JobOutputTypeMlflowModel JobOutputType = "mlflow_model"
	JobOutputTypeMltable     JobOutputType = "mltable"
	JobOutputTypeTritonModel JobOutputType = "triton_model"
	JobOutputTypeURIFile     JobOutputType = "uri_file"
	JobOutputTypeURIFolder   JobOutputType = "uri_folder"
)

// PossibleJobOutputTypeValues returns the possible values for the JobOutputType const type.
func PossibleJobOutputTypeValues() []JobOutputType {
	return []JobOutputType{
		JobOutputTypeCustomModel,
		JobOutputTypeMlflowModel,
		JobOutputTypeMltable,
		JobOutputTypeTritonModel,
		JobOutputTypeURIFile,
		JobOutputTypeURIFolder,
	}
}

// JobStatus - The status of a job.
type JobStatus string

const (
	// JobStatusCancelRequested - Cancellation has been requested for the job.
	JobStatusCancelRequested JobStatus = "CancelRequested"
	// JobStatusCanceled - Following cancellation request, the job is now successfully canceled.
	JobStatusCanceled JobStatus = "Canceled"
	// JobStatusCompleted - Job completed successfully. This reflects that both the job itself and output collection states completed
	// successfully
	JobStatusCompleted JobStatus = "Completed"
	// JobStatusFailed - Job failed.
	JobStatusFailed JobStatus = "Failed"
	// JobStatusFinalizing - Job is completed in the target. It is in output collection state now.
	JobStatusFinalizing JobStatus = "Finalizing"
	// JobStatusNotResponding - When heartbeat is enabled, if the run isn't updating any information to RunHistory then the run
	// goes to NotResponding state.
	// NotResponding is the only state that is exempt from strict transition orders. A run can go from NotResponding to any of
	// the previous states.
	JobStatusNotResponding JobStatus = "NotResponding"
	// JobStatusNotStarted - Run hasn't started yet.
	JobStatusNotStarted JobStatus = "NotStarted"
	// JobStatusPaused - The job is paused by users. Some adjustment to labeling jobs can be made only in paused state.
	JobStatusPaused JobStatus = "Paused"
	// JobStatusPreparing - The run environment is being prepared.
	JobStatusPreparing JobStatus = "Preparing"
	// JobStatusProvisioning - (Not used currently) It will be used if ES is creating the compute target.
	JobStatusProvisioning JobStatus = "Provisioning"
	// JobStatusQueued - The job is queued in the compute target. For example, in BatchAI the job is in queued state, while waiting
	// for all required nodes to be ready.
	JobStatusQueued JobStatus = "Queued"
	// JobStatusRunning - The job started to run in the compute target.
	JobStatusRunning JobStatus = "Running"
	// JobStatusStarting - Run has started. The user has a run ID.
	JobStatusStarting JobStatus = "Starting"
	// JobStatusUnknown - Default job status if not mapped to all other statuses
	JobStatusUnknown JobStatus = "Unknown"
)

// PossibleJobStatusValues returns the possible values for the JobStatus const type.
func PossibleJobStatusValues() []JobStatus {
	return []JobStatus{
		JobStatusCancelRequested,
		JobStatusCanceled,
		JobStatusCompleted,
		JobStatusFailed,
		JobStatusFinalizing,
		JobStatusNotResponding,
		JobStatusNotStarted,
		JobStatusPaused,
		JobStatusPreparing,
		JobStatusProvisioning,
		JobStatusQueued,
		JobStatusRunning,
		JobStatusStarting,
		JobStatusUnknown,
	}
}

// JobTier - Enum to determine the job tier.
type JobTier string

const (
	JobTierBasic    JobTier = "Basic"
	JobTierNull     JobTier = "Null"
	JobTierPremium  JobTier = "Premium"
	JobTierSpot     JobTier = "Spot"
	JobTierStandard JobTier = "Standard"
)

// PossibleJobTierValues returns the possible values for the JobTier const type.
func PossibleJobTierValues() []JobTier {
	return []JobTier{
		JobTierBasic,
		JobTierNull,
		JobTierPremium,
		JobTierSpot,
		JobTierStandard,
	}
}

// JobType - Enum to determine the type of job.
type JobType string

const (
	JobTypeAutoML   JobType = "AutoML"
	JobTypeCommand  JobType = "Command"
	JobTypePipeline JobType = "Pipeline"
	JobTypeSpark    JobType = "Spark"
	JobTypeSweep    JobType = "Sweep"
)

// PossibleJobTypeValues returns the possible values for the JobType const type.
func PossibleJobTypeValues() []JobType {
	return []JobType{
		JobTypeAutoML,
		JobTypeCommand,
		JobTypePipeline,
		JobTypeSpark,
		JobTypeSweep,
	}
}

type KeyType string

const (
	KeyTypePrimary   KeyType = "Primary"
	KeyTypeSecondary KeyType = "Secondary"
)

// PossibleKeyTypeValues returns the possible values for the KeyType const type.
func PossibleKeyTypeValues() []KeyType {
	return []KeyType{
		KeyTypePrimary,
		KeyTypeSecondary,
	}
}

// LearningRateScheduler - Learning rate scheduler enum.
type LearningRateScheduler string

const (
	// LearningRateSchedulerNone - No learning rate scheduler selected.
	LearningRateSchedulerNone LearningRateScheduler = "None"
	// LearningRateSchedulerStep - Step learning rate scheduler.
	LearningRateSchedulerStep LearningRateScheduler = "Step"
	// LearningRateSchedulerWarmupCosine - Cosine Annealing With Warmup.
	LearningRateSchedulerWarmupCosine LearningRateScheduler = "WarmupCosine"
)

// PossibleLearningRateSchedulerValues returns the possible values for the LearningRateScheduler const type.
func PossibleLearningRateSchedulerValues() []LearningRateScheduler {
	return []LearningRateScheduler{
		LearningRateSchedulerNone,
		LearningRateSchedulerStep,
		LearningRateSchedulerWarmupCosine,
	}
}

type ListViewType string

const (
	ListViewTypeActiveOnly   ListViewType = "ActiveOnly"
	ListViewTypeAll          ListViewType = "All"
	ListViewTypeArchivedOnly ListViewType = "ArchivedOnly"
)

// PossibleListViewTypeValues returns the possible values for the ListViewType const type.
func PossibleListViewTypeValues() []ListViewType {
	return []ListViewType{
		ListViewTypeActiveOnly,
		ListViewTypeAll,
		ListViewTypeArchivedOnly,
	}
}

// LoadBalancerType - Load Balancer Type
type LoadBalancerType string

const (
	LoadBalancerTypeInternalLoadBalancer LoadBalancerType = "InternalLoadBalancer"
	LoadBalancerTypePublicIP             LoadBalancerType = "PublicIp"
)

// PossibleLoadBalancerTypeValues returns the possible values for the LoadBalancerType const type.
func PossibleLoadBalancerTypeValues() []LoadBalancerType {
	return []LoadBalancerType{
		LoadBalancerTypeInternalLoadBalancer,
		LoadBalancerTypePublicIP,
	}
}

// LogVerbosity - Enum for setting log verbosity.
type LogVerbosity string

const (
	// LogVerbosityCritical - Only critical statements logged.
	LogVerbosityCritical LogVerbosity = "Critical"
	// LogVerbosityDebug - Debug and above log statements logged.
	LogVerbosityDebug LogVerbosity = "Debug"
	// LogVerbosityError - Error and above log statements logged.
	LogVerbosityError LogVerbosity = "Error"
	// LogVerbosityInfo - Info and above log statements logged.
	LogVerbosityInfo LogVerbosity = "Info"
	// LogVerbosityNotSet - No logs emitted.
	LogVerbosityNotSet LogVerbosity = "NotSet"
	// LogVerbosityWarning - Warning and above log statements logged.
	LogVerbosityWarning LogVerbosity = "Warning"
)

// PossibleLogVerbosityValues returns the possible values for the LogVerbosity const type.
func PossibleLogVerbosityValues() []LogVerbosity {
	return []LogVerbosity{
		LogVerbosityCritical,
		LogVerbosityDebug,
		LogVerbosityError,
		LogVerbosityInfo,
		LogVerbosityNotSet,
		LogVerbosityWarning,
	}
}

// ManagedNetworkStatus - Status for the managed network of a machine learning workspace.
type ManagedNetworkStatus string

const (
	ManagedNetworkStatusActive   ManagedNetworkStatus = "Active"
	ManagedNetworkStatusInactive ManagedNetworkStatus = "Inactive"
)

// PossibleManagedNetworkStatusValues returns the possible values for the ManagedNetworkStatus const type.
func PossibleManagedNetworkStatusValues() []ManagedNetworkStatus {
	return []ManagedNetworkStatus{
		ManagedNetworkStatusActive,
		ManagedNetworkStatusInactive,
	}
}

// ManagedServiceIdentityType - Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
type ManagedServiceIdentityType string

const (
	ManagedServiceIdentityTypeNone                       ManagedServiceIdentityType = "None"
	ManagedServiceIdentityTypeSystemAssigned             ManagedServiceIdentityType = "SystemAssigned"
	ManagedServiceIdentityTypeSystemAssignedUserAssigned ManagedServiceIdentityType = "SystemAssigned,UserAssigned"
	ManagedServiceIdentityTypeUserAssigned               ManagedServiceIdentityType = "UserAssigned"
)

// PossibleManagedServiceIdentityTypeValues returns the possible values for the ManagedServiceIdentityType const type.
func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType {
	return []ManagedServiceIdentityType{
		ManagedServiceIdentityTypeNone,
		ManagedServiceIdentityTypeSystemAssigned,
		ManagedServiceIdentityTypeSystemAssignedUserAssigned,
		ManagedServiceIdentityTypeUserAssigned,
	}
}

type MarketplaceSubscriptionProvisioningState string

const (
	MarketplaceSubscriptionProvisioningStateCanceled MarketplaceSubscriptionProvisioningState = "Canceled"
	// MarketplaceSubscriptionProvisioningStateCreating - MarketplaceSubscription is being created.
	MarketplaceSubscriptionProvisioningStateCreating MarketplaceSubscriptionProvisioningState = "Creating"
	// MarketplaceSubscriptionProvisioningStateDeleting - MarketplaceSubscription is being deleted.
	MarketplaceSubscriptionProvisioningStateDeleting MarketplaceSubscriptionProvisioningState = "Deleting"
	// MarketplaceSubscriptionProvisioningStateFailed - MarketplaceSubscription provisioning failed.
	MarketplaceSubscriptionProvisioningStateFailed MarketplaceSubscriptionProvisioningState = "Failed"
	// MarketplaceSubscriptionProvisioningStateSucceeded - MarketplaceSubscription is successfully provisioned.
	MarketplaceSubscriptionProvisioningStateSucceeded MarketplaceSubscriptionProvisioningState = "Succeeded"
	// MarketplaceSubscriptionProvisioningStateUpdating - MarketplaceSubscription is being updated.
	MarketplaceSubscriptionProvisioningStateUpdating MarketplaceSubscriptionProvisioningState = "Updating"
)

// PossibleMarketplaceSubscriptionProvisioningStateValues returns the possible values for the MarketplaceSubscriptionProvisioningState const type.
func PossibleMarketplaceSubscriptionProvisioningStateValues() []MarketplaceSubscriptionProvisioningState {
	return []MarketplaceSubscriptionProvisioningState{
		MarketplaceSubscriptionProvisioningStateCanceled,
		MarketplaceSubscriptionProvisioningStateCreating,
		MarketplaceSubscriptionProvisioningStateDeleting,
		MarketplaceSubscriptionProvisioningStateFailed,
		MarketplaceSubscriptionProvisioningStateSucceeded,
		MarketplaceSubscriptionProvisioningStateUpdating,
	}
}

type MarketplaceSubscriptionStatus string

const (
	// MarketplaceSubscriptionStatusSubscribed - The customer can now use the Marketplace Subscription's
	// model and will be billed.
	MarketplaceSubscriptionStatusSubscribed MarketplaceSubscriptionStatus = "Subscribed"
	// MarketplaceSubscriptionStatusSuspended - The customer could not be billed for the Marketplace Subscription.
	// The customer will not be able to access the model.
	MarketplaceSubscriptionStatusSuspended MarketplaceSubscriptionStatus = "Suspended"
	// MarketplaceSubscriptionStatusUnsubscribed - Marketplace Subscriptions reach this state in response to an explicit customer
	// or CSP action.
	// A Marketplace Subscription can also be canceled implicitly, as a result of nonpayment of dues,
	// after being in the Suspended state for some time.
	MarketplaceSubscriptionStatusUnsubscribed MarketplaceSubscriptionStatus = "Unsubscribed"
)

// PossibleMarketplaceSubscriptionStatusValues returns the possible values for the MarketplaceSubscriptionStatus const type.
func PossibleMarketplaceSubscriptionStatusValues() []MarketplaceSubscriptionStatus {
	return []MarketplaceSubscriptionStatus{
		MarketplaceSubscriptionStatusSubscribed,
		MarketplaceSubscriptionStatusSuspended,
		MarketplaceSubscriptionStatusUnsubscribed,
	}
}

type MaterializationStoreType string

const (
	MaterializationStoreTypeNone             MaterializationStoreType = "None"
	MaterializationStoreTypeOffline          MaterializationStoreType = "Offline"
	MaterializationStoreTypeOnline           MaterializationStoreType = "Online"
	MaterializationStoreTypeOnlineAndOffline MaterializationStoreType = "OnlineAndOffline"
)

// PossibleMaterializationStoreTypeValues returns the possible values for the MaterializationStoreType const type.
func PossibleMaterializationStoreTypeValues() []MaterializationStoreType {
	return []MaterializationStoreType{
		MaterializationStoreTypeNone,
		MaterializationStoreTypeOffline,
		MaterializationStoreTypeOnline,
		MaterializationStoreTypeOnlineAndOffline,
	}
}

// ModelSize - Image model size.
type ModelSize string

const (
	// ModelSizeExtraLarge - Extra large size.
	ModelSizeExtraLarge ModelSize = "ExtraLarge"
	// ModelSizeLarge - Large size.
	ModelSizeLarge ModelSize = "Large"
	// ModelSizeMedium - Medium size.
	ModelSizeMedium ModelSize = "Medium"
	// ModelSizeNone - No value selected.
	ModelSizeNone ModelSize = "None"
	// ModelSizeSmall - Small size.
	ModelSizeSmall ModelSize = "Small"
)

// PossibleModelSizeValues returns the possible values for the ModelSize const type.
func PossibleModelSizeValues() []ModelSize {
	return []ModelSize{
		ModelSizeExtraLarge,
		ModelSizeLarge,
		ModelSizeMedium,
		ModelSizeNone,
		ModelSizeSmall,
	}
}

// ModelTaskType - Model task type enum.
type ModelTaskType string

const (
	ModelTaskTypeClassification ModelTaskType = "Classification"
	ModelTaskTypeRegression     ModelTaskType = "Regression"
)

// PossibleModelTaskTypeValues returns the possible values for the ModelTaskType const type.
func PossibleModelTaskTypeValues() []ModelTaskType {
	return []ModelTaskType{
		ModelTaskTypeClassification,
		ModelTaskTypeRegression,
	}
}

// MonitorComputeIdentityType - Monitor compute identity type enum.
type MonitorComputeIdentityType string

const (
	// MonitorComputeIdentityTypeAmlToken - Authenticates through user's AML token.
	MonitorComputeIdentityTypeAmlToken MonitorComputeIdentityType = "AmlToken"
	// MonitorComputeIdentityTypeManagedIdentity - Authenticates through a user-provided managed identity.
	MonitorComputeIdentityTypeManagedIdentity MonitorComputeIdentityType = "ManagedIdentity"
)

// PossibleMonitorComputeIdentityTypeValues returns the possible values for the MonitorComputeIdentityType const type.
func PossibleMonitorComputeIdentityTypeValues() []MonitorComputeIdentityType {
	return []MonitorComputeIdentityType{
		MonitorComputeIdentityTypeAmlToken,
		MonitorComputeIdentityTypeManagedIdentity,
	}
}

// MonitorComputeType - Monitor compute type enum.
type MonitorComputeType string

const (
	// MonitorComputeTypeServerlessSpark - Serverless Spark compute.
	MonitorComputeTypeServerlessSpark MonitorComputeType = "ServerlessSpark"
)

// PossibleMonitorComputeTypeValues returns the possible values for the MonitorComputeType const type.
func PossibleMonitorComputeTypeValues() []MonitorComputeType {
	return []MonitorComputeType{
		MonitorComputeTypeServerlessSpark,
	}
}

type MonitoringFeatureDataType string

const (
	// MonitoringFeatureDataTypeCategorical - Used for features of categorical data type.
	MonitoringFeatureDataTypeCategorical MonitoringFeatureDataType = "Categorical"
	// MonitoringFeatureDataTypeNumerical - Used for features of numerical data type.
	MonitoringFeatureDataTypeNumerical MonitoringFeatureDataType = "Numerical"
)

// PossibleMonitoringFeatureDataTypeValues returns the possible values for the MonitoringFeatureDataType const type.
func PossibleMonitoringFeatureDataTypeValues() []MonitoringFeatureDataType {
	return []MonitoringFeatureDataType{
		MonitoringFeatureDataTypeCategorical,
		MonitoringFeatureDataTypeNumerical,
	}
}

type MonitoringFeatureFilterType string

const (
	// MonitoringFeatureFilterTypeAllFeatures - Includes all features.
	MonitoringFeatureFilterTypeAllFeatures MonitoringFeatureFilterType = "AllFeatures"
	// MonitoringFeatureFilterTypeFeatureSubset - Includes a user-defined subset of features.
	MonitoringFeatureFilterTypeFeatureSubset MonitoringFeatureFilterType = "FeatureSubset"
	// MonitoringFeatureFilterTypeTopNByAttribution - Only includes the top contributing features, measured by feature attribution.
	MonitoringFeatureFilterTypeTopNByAttribution MonitoringFeatureFilterType = "TopNByAttribution"
)

// PossibleMonitoringFeatureFilterTypeValues returns the possible values for the MonitoringFeatureFilterType const type.
func PossibleMonitoringFeatureFilterTypeValues() []MonitoringFeatureFilterType {
	return []MonitoringFeatureFilterType{
		MonitoringFeatureFilterTypeAllFeatures,
		MonitoringFeatureFilterTypeFeatureSubset,
		MonitoringFeatureFilterTypeTopNByAttribution,
	}
}

// MonitoringInputDataType - Monitoring input data type enum.
type MonitoringInputDataType string

const (
	// MonitoringInputDataTypeFixed - An input data with tabular format which doesn't require preprocessing.
	MonitoringInputDataTypeFixed MonitoringInputDataType = "Fixed"
	// MonitoringInputDataTypeRolling - An input data which rolls relatively to the monitor's current run time.
	MonitoringInputDataTypeRolling MonitoringInputDataType = "Rolling"
	// MonitoringInputDataTypeStatic - An input data with a fixed window size.
	MonitoringInputDataTypeStatic MonitoringInputDataType = "Static"
)

// PossibleMonitoringInputDataTypeValues returns the possible values for the MonitoringInputDataType const type.
func PossibleMonitoringInputDataTypeValues() []MonitoringInputDataType {
	return []MonitoringInputDataType{
		MonitoringInputDataTypeFixed,
		MonitoringInputDataTypeRolling,
		MonitoringInputDataTypeStatic,
	}
}

type MonitoringNotificationType string

const (
	// MonitoringNotificationTypeAmlNotification - Enables email notifications through AML notifications.
	MonitoringNotificationTypeAmlNotification MonitoringNotificationType = "AmlNotification"
)

// PossibleMonitoringNotificationTypeValues returns the possible values for the MonitoringNotificationType const type.
func PossibleMonitoringNotificationTypeValues() []MonitoringNotificationType {
	return []MonitoringNotificationType{
		MonitoringNotificationTypeAmlNotification,
	}
}

type MonitoringSignalType string

const (
	// MonitoringSignalTypeCustom - Tracks a custom signal provided by users.
	MonitoringSignalTypeCustom MonitoringSignalType = "Custom"
	// MonitoringSignalTypeDataDrift - Tracks model input data distribution change, comparing against training data or past production
	// data.
	MonitoringSignalTypeDataDrift MonitoringSignalType = "DataDrift"
	// MonitoringSignalTypeDataQuality - Tracks model input data integrity.
	MonitoringSignalTypeDataQuality MonitoringSignalType = "DataQuality"
	// MonitoringSignalTypeFeatureAttributionDrift - Tracks feature importance change in production, comparing against feature
	// importance at training time.
	MonitoringSignalTypeFeatureAttributionDrift MonitoringSignalType = "FeatureAttributionDrift"
	// MonitoringSignalTypePredictionDrift - Tracks prediction result data distribution change, comparing against validation/test
	// label data or past production data.
	MonitoringSignalTypePredictionDrift MonitoringSignalType = "PredictionDrift"
)

// PossibleMonitoringSignalTypeValues returns the possible values for the MonitoringSignalType const type.
func PossibleMonitoringSignalTypeValues() []MonitoringSignalType {
	return []MonitoringSignalType{
		MonitoringSignalTypeCustom,
		MonitoringSignalTypeDataDrift,
		MonitoringSignalTypeDataQuality,
		MonitoringSignalTypeFeatureAttributionDrift,
		MonitoringSignalTypePredictionDrift,
	}
}

// MountAction - Mount Action.
type MountAction string

const (
	MountActionMount   MountAction = "Mount"
	MountActionUnmount MountAction = "Unmount"
)

// PossibleMountActionValues returns the possible values for the MountAction const type.
func PossibleMountActionValues() []MountAction {
	return []MountAction{
		MountActionMount,
		MountActionUnmount,
	}
}

// MountState - Mount state.
type MountState string

const (
	MountStateMountFailed      MountState = "MountFailed"
	MountStateMountRequested   MountState = "MountRequested"
	MountStateMounted          MountState = "Mounted"
	MountStateUnmountFailed    MountState = "UnmountFailed"
	MountStateUnmountRequested MountState = "UnmountRequested"
	MountStateUnmounted        MountState = "Unmounted"
)

// PossibleMountStateValues returns the possible values for the MountState const type.
func PossibleMountStateValues() []MountState {
	return []MountState{
		MountStateMountFailed,
		MountStateMountRequested,
		MountStateMounted,
		MountStateUnmountFailed,
		MountStateUnmountRequested,
		MountStateUnmounted,
	}
}

// NCrossValidationsMode - Determines how N-Cross validations value is determined.
type NCrossValidationsMode string

const (
	// NCrossValidationsModeAuto - Determine N-Cross validations value automatically. Supported only for 'Forecasting' AutoML
	// task.
	NCrossValidationsModeAuto NCrossValidationsMode = "Auto"
	// NCrossValidationsModeCustom - Use custom N-Cross validations value.
	NCrossValidationsModeCustom NCrossValidationsMode = "Custom"
)

// PossibleNCrossValidationsModeValues returns the possible values for the NCrossValidationsMode const type.
func PossibleNCrossValidationsModeValues() []NCrossValidationsMode {
	return []NCrossValidationsMode{
		NCrossValidationsModeAuto,
		NCrossValidationsModeCustom,
	}
}

// Network - network of this container.
type Network string

const (
	NetworkBridge Network = "Bridge"
	NetworkHost   Network = "Host"
)

// PossibleNetworkValues returns the possible values for the Network const type.
func PossibleNetworkValues() []Network {
	return []Network{
		NetworkBridge,
		NetworkHost,
	}
}

// NodeState - State of the compute node. Values are idle, running, preparing, unusable, leaving and preempted.
type NodeState string

const (
	NodeStateIdle      NodeState = "idle"
	NodeStateLeaving   NodeState = "leaving"
	NodeStatePreempted NodeState = "preempted"
	NodeStatePreparing NodeState = "preparing"
	NodeStateRunning   NodeState = "running"
	NodeStateUnusable  NodeState = "unusable"
)

// PossibleNodeStateValues returns the possible values for the NodeState const type.
func PossibleNodeStateValues() []NodeState {
	return []NodeState{
		NodeStateIdle,
		NodeStateLeaving,
		NodeStatePreempted,
		NodeStatePreparing,
		NodeStateRunning,
		NodeStateUnusable,
	}
}

// NodesValueType - The enumerated types for the nodes value
type NodesValueType string

const (
	NodesValueTypeAll NodesValueType = "All"
)

// PossibleNodesValueTypeValues returns the possible values for the NodesValueType const type.
func PossibleNodesValueTypeValues() []NodesValueType {
	return []NodesValueType{
		NodesValueTypeAll,
	}
}

type NumericalDataDriftMetric string

const (
	// NumericalDataDriftMetricJensenShannonDistance - The Jensen Shannon Distance (JSD) metric.
	NumericalDataDriftMetricJensenShannonDistance NumericalDataDriftMetric = "JensenShannonDistance"
	// NumericalDataDriftMetricNormalizedWassersteinDistance - The Normalized Wasserstein Distance metric.
	NumericalDataDriftMetricNormalizedWassersteinDistance NumericalDataDriftMetric = "NormalizedWassersteinDistance"
	// NumericalDataDriftMetricPopulationStabilityIndex - The Population Stability Index (PSI) metric.
	NumericalDataDriftMetricPopulationStabilityIndex NumericalDataDriftMetric = "PopulationStabilityIndex"
	// NumericalDataDriftMetricTwoSampleKolmogorovSmirnovTest - The Two Sample Kolmogorov-Smirnov Test (two-sample K–S) metric.
	NumericalDataDriftMetricTwoSampleKolmogorovSmirnovTest NumericalDataDriftMetric = "TwoSampleKolmogorovSmirnovTest"
)

// PossibleNumericalDataDriftMetricValues returns the possible values for the NumericalDataDriftMetric const type.
func PossibleNumericalDataDriftMetricValues() []NumericalDataDriftMetric {
	return []NumericalDataDriftMetric{
		NumericalDataDriftMetricJensenShannonDistance,
		NumericalDataDriftMetricNormalizedWassersteinDistance,
		NumericalDataDriftMetricPopulationStabilityIndex,
		NumericalDataDriftMetricTwoSampleKolmogorovSmirnovTest,
	}
}

type NumericalDataQualityMetric string

const (
	// NumericalDataQualityMetricDataTypeErrorRate - Calculates the rate of data type errors.
	NumericalDataQualityMetricDataTypeErrorRate NumericalDataQualityMetric = "DataTypeErrorRate"
	// NumericalDataQualityMetricNullValueRate - Calculates the rate of null values.
	NumericalDataQualityMetricNullValueRate NumericalDataQualityMetric = "NullValueRate"
	// NumericalDataQualityMetricOutOfBoundsRate - Calculates the rate values are out of bounds.
	NumericalDataQualityMetricOutOfBoundsRate NumericalDataQualityMetric = "OutOfBoundsRate"
)

// PossibleNumericalDataQualityMetricValues returns the possible values for the NumericalDataQualityMetric const type.
func PossibleNumericalDataQualityMetricValues() []NumericalDataQualityMetric {
	return []NumericalDataQualityMetric{
		NumericalDataQualityMetricDataTypeErrorRate,
		NumericalDataQualityMetricNullValueRate,
		NumericalDataQualityMetricOutOfBoundsRate,
	}
}

type NumericalPredictionDriftMetric string

const (
	// NumericalPredictionDriftMetricJensenShannonDistance - The Jensen Shannon Distance (JSD) metric.
	NumericalPredictionDriftMetricJensenShannonDistance NumericalPredictionDriftMetric = "JensenShannonDistance"
	// NumericalPredictionDriftMetricNormalizedWassersteinDistance - The Normalized Wasserstein Distance metric.
	NumericalPredictionDriftMetricNormalizedWassersteinDistance NumericalPredictionDriftMetric = "NormalizedWassersteinDistance"
	// NumericalPredictionDriftMetricPopulationStabilityIndex - The Population Stability Index (PSI) metric.
	NumericalPredictionDriftMetricPopulationStabilityIndex NumericalPredictionDriftMetric = "PopulationStabilityIndex"
	// NumericalPredictionDriftMetricTwoSampleKolmogorovSmirnovTest - The Two Sample Kolmogorov-Smirnov Test (two-sample K–S)
	// metric.
	NumericalPredictionDriftMetricTwoSampleKolmogorovSmirnovTest NumericalPredictionDriftMetric = "TwoSampleKolmogorovSmirnovTest"
)

// PossibleNumericalPredictionDriftMetricValues returns the possible values for the NumericalPredictionDriftMetric const type.
func PossibleNumericalPredictionDriftMetricValues() []NumericalPredictionDriftMetric {
	return []NumericalPredictionDriftMetric{
		NumericalPredictionDriftMetricJensenShannonDistance,
		NumericalPredictionDriftMetricNormalizedWassersteinDistance,
		NumericalPredictionDriftMetricPopulationStabilityIndex,
		NumericalPredictionDriftMetricTwoSampleKolmogorovSmirnovTest,
	}
}

// ObjectDetectionPrimaryMetrics - Primary metrics for Image ObjectDetection task.
type ObjectDetectionPrimaryMetrics string

const (
	// ObjectDetectionPrimaryMetricsMeanAveragePrecision - Mean Average Precision (MAP) is the average of AP (Average Precision).
	// AP is calculated for each class and averaged to get the MAP.
	ObjectDetectionPrimaryMetricsMeanAveragePrecision ObjectDetectionPrimaryMetrics = "MeanAveragePrecision"
)

// PossibleObjectDetectionPrimaryMetricsValues returns the possible values for the ObjectDetectionPrimaryMetrics const type.
func PossibleObjectDetectionPrimaryMetricsValues() []ObjectDetectionPrimaryMetrics {
	return []ObjectDetectionPrimaryMetrics{
		ObjectDetectionPrimaryMetricsMeanAveragePrecision,
	}
}

// OneLakeArtifactType - Enum to determine OneLake artifact type.
type OneLakeArtifactType string

const (
	OneLakeArtifactTypeLakeHouse OneLakeArtifactType = "LakeHouse"
)

// PossibleOneLakeArtifactTypeValues returns the possible values for the OneLakeArtifactType const type.
func PossibleOneLakeArtifactTypeValues() []OneLakeArtifactType {
	return []OneLakeArtifactType{
		OneLakeArtifactTypeLakeHouse,
	}
}

// OperatingSystemType - The type of operating system.
type OperatingSystemType string

const (
	OperatingSystemTypeLinux   OperatingSystemType = "Linux"
	OperatingSystemTypeWindows OperatingSystemType = "Windows"
)

// PossibleOperatingSystemTypeValues returns the possible values for the OperatingSystemType const type.
func PossibleOperatingSystemTypeValues() []OperatingSystemType {
	return []OperatingSystemType{
		OperatingSystemTypeLinux,
		OperatingSystemTypeWindows,
	}
}

// OperationName - Name of the last operation.
type OperationName string

const (
	OperationNameCreate  OperationName = "Create"
	OperationNameDelete  OperationName = "Delete"
	OperationNameReimage OperationName = "Reimage"
	OperationNameRestart OperationName = "Restart"
	OperationNameStart   OperationName = "Start"
	OperationNameStop    OperationName = "Stop"
)

// PossibleOperationNameValues returns the possible values for the OperationName const type.
func PossibleOperationNameValues() []OperationName {
	return []OperationName{
		OperationNameCreate,
		OperationNameDelete,
		OperationNameReimage,
		OperationNameRestart,
		OperationNameStart,
		OperationNameStop,
	}
}

// OperationStatus - Operation status.
type OperationStatus string

const (
	OperationStatusCreateFailed  OperationStatus = "CreateFailed"
	OperationStatusDeleteFailed  OperationStatus = "DeleteFailed"
	OperationStatusInProgress    OperationStatus = "InProgress"
	OperationStatusReimageFailed OperationStatus = "ReimageFailed"
	OperationStatusRestartFailed OperationStatus = "RestartFailed"
	OperationStatusStartFailed   OperationStatus = "StartFailed"
	OperationStatusStopFailed    OperationStatus = "StopFailed"
	OperationStatusSucceeded     OperationStatus = "Succeeded"
)

// PossibleOperationStatusValues returns the possible values for the OperationStatus const type.
func PossibleOperationStatusValues() []OperationStatus {
	return []OperationStatus{
		OperationStatusCreateFailed,
		OperationStatusDeleteFailed,
		OperationStatusInProgress,
		OperationStatusReimageFailed,
		OperationStatusRestartFailed,
		OperationStatusStartFailed,
		OperationStatusStopFailed,
		OperationStatusSucceeded,
	}
}

// OperationTrigger - Trigger of operation.
type OperationTrigger string

const (
	OperationTriggerIdleShutdown OperationTrigger = "IdleShutdown"
	OperationTriggerSchedule     OperationTrigger = "Schedule"
	OperationTriggerUser         OperationTrigger = "User"
)

// PossibleOperationTriggerValues returns the possible values for the OperationTrigger const type.
func PossibleOperationTriggerValues() []OperationTrigger {
	return []OperationTrigger{
		OperationTriggerIdleShutdown,
		OperationTriggerSchedule,
		OperationTriggerUser,
	}
}

type OrderString string

const (
	OrderStringCreatedAtAsc  OrderString = "CreatedAtAsc"
	OrderStringCreatedAtDesc OrderString = "CreatedAtDesc"
	OrderStringUpdatedAtAsc  OrderString = "UpdatedAtAsc"
	OrderStringUpdatedAtDesc OrderString = "UpdatedAtDesc"
)

// PossibleOrderStringValues returns the possible values for the OrderString const type.
func PossibleOrderStringValues() []OrderString {
	return []OrderString{
		OrderStringCreatedAtAsc,
		OrderStringCreatedAtDesc,
		OrderStringUpdatedAtAsc,
		OrderStringUpdatedAtDesc,
	}
}

// Origin - The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default
// value is "user,system"
type Origin string

const (
	OriginSystem     Origin = "system"
	OriginUser       Origin = "user"
	OriginUserSystem Origin = "user,system"
)

// PossibleOriginValues returns the possible values for the Origin const type.
func PossibleOriginValues() []Origin {
	return []Origin{
		OriginSystem,
		OriginUser,
		OriginUserSystem,
	}
}

// OsType - Compute OS Type
type OsType string

const (
	OsTypeLinux   OsType = "Linux"
	OsTypeWindows OsType = "Windows"
)

// PossibleOsTypeValues returns the possible values for the OsType const type.
func PossibleOsTypeValues() []OsType {
	return []OsType{
		OsTypeLinux,
		OsTypeWindows,
	}
}

// OutputDeliveryMode - Output data delivery mode enums.
type OutputDeliveryMode string

const (
	OutputDeliveryModeDirect         OutputDeliveryMode = "Direct"
	OutputDeliveryModeReadWriteMount OutputDeliveryMode = "ReadWriteMount"
	OutputDeliveryModeUpload         OutputDeliveryMode = "Upload"
)

// PossibleOutputDeliveryModeValues returns the possible values for the OutputDeliveryMode const type.
func PossibleOutputDeliveryModeValues() []OutputDeliveryMode {
	return []OutputDeliveryMode{
		OutputDeliveryModeDirect,
		OutputDeliveryModeReadWriteMount,
		OutputDeliveryModeUpload,
	}
}

// PendingUploadCredentialType - Enum to determine the PendingUpload credentials type.
type PendingUploadCredentialType string

const (
	PendingUploadCredentialTypeSAS PendingUploadCredentialType = "SAS"
)

// PossiblePendingUploadCredentialTypeValues returns the possible values for the PendingUploadCredentialType const type.
func PossiblePendingUploadCredentialTypeValues() []PendingUploadCredentialType {
	return []PendingUploadCredentialType{
		PendingUploadCredentialTypeSAS,
	}
}

// PendingUploadType - Type of storage to use for the pending upload location
type PendingUploadType string

const (
	PendingUploadTypeNone                   PendingUploadType = "None"
	PendingUploadTypeTemporaryBlobReference PendingUploadType = "TemporaryBlobReference"
)

// PossiblePendingUploadTypeValues returns the possible values for the PendingUploadType const type.
func PossiblePendingUploadTypeValues() []PendingUploadType {
	return []PendingUploadType{
		PendingUploadTypeNone,
		PendingUploadTypeTemporaryBlobReference,
	}
}

// PrivateEndpointConnectionProvisioningState - The current provisioning state.
type PrivateEndpointConnectionProvisioningState string

const (
	PrivateEndpointConnectionProvisioningStateCreating  PrivateEndpointConnectionProvisioningState = "Creating"
	PrivateEndpointConnectionProvisioningStateDeleting  PrivateEndpointConnectionProvisioningState = "Deleting"
	PrivateEndpointConnectionProvisioningStateFailed    PrivateEndpointConnectionProvisioningState = "Failed"
	PrivateEndpointConnectionProvisioningStateSucceeded PrivateEndpointConnectionProvisioningState = "Succeeded"
)

// PossiblePrivateEndpointConnectionProvisioningStateValues returns the possible values for the PrivateEndpointConnectionProvisioningState const type.
func PossiblePrivateEndpointConnectionProvisioningStateValues() []PrivateEndpointConnectionProvisioningState {
	return []PrivateEndpointConnectionProvisioningState{
		PrivateEndpointConnectionProvisioningStateCreating,
		PrivateEndpointConnectionProvisioningStateDeleting,
		PrivateEndpointConnectionProvisioningStateFailed,
		PrivateEndpointConnectionProvisioningStateSucceeded,
	}
}

// PrivateEndpointServiceConnectionStatus - The private endpoint connection status.
type PrivateEndpointServiceConnectionStatus string

const (
	PrivateEndpointServiceConnectionStatusApproved     PrivateEndpointServiceConnectionStatus = "Approved"
	PrivateEndpointServiceConnectionStatusDisconnected PrivateEndpointServiceConnectionStatus = "Disconnected"
	PrivateEndpointServiceConnectionStatusPending      PrivateEndpointServiceConnectionStatus = "Pending"
	PrivateEndpointServiceConnectionStatusRejected     PrivateEndpointServiceConnectionStatus = "Rejected"
	PrivateEndpointServiceConnectionStatusTimeout      PrivateEndpointServiceConnectionStatus = "Timeout"
)

// PossiblePrivateEndpointServiceConnectionStatusValues returns the possible values for the PrivateEndpointServiceConnectionStatus const type.
func PossiblePrivateEndpointServiceConnectionStatusValues() []PrivateEndpointServiceConnectionStatus {
	return []PrivateEndpointServiceConnectionStatus{
		PrivateEndpointServiceConnectionStatusApproved,
		PrivateEndpointServiceConnectionStatusDisconnected,
		PrivateEndpointServiceConnectionStatusPending,
		PrivateEndpointServiceConnectionStatusRejected,
		PrivateEndpointServiceConnectionStatusTimeout,
	}
}

// Protocol - Protocol over which communication will happen over this endpoint
type Protocol string

const (
	ProtocolHTTP Protocol = "http"
	ProtocolTCP  Protocol = "tcp"
	ProtocolUDP  Protocol = "udp"
)

// PossibleProtocolValues returns the possible values for the Protocol const type.
func PossibleProtocolValues() []Protocol {
	return []Protocol{
		ProtocolHTTP,
		ProtocolTCP,
		ProtocolUDP,
	}
}

// ProvisioningState - The current deployment state of workspace resource. The provisioningState is to indicate states for
// resource provisioning.
type ProvisioningState string

const (
	ProvisioningStateCanceled  ProvisioningState = "Canceled"
	ProvisioningStateCreating  ProvisioningState = "Creating"
	ProvisioningStateDeleting  ProvisioningState = "Deleting"
	ProvisioningStateFailed    ProvisioningState = "Failed"
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
	ProvisioningStateUnknown   ProvisioningState = "Unknown"
	ProvisioningStateUpdating  ProvisioningState = "Updating"
)

// PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.
func PossibleProvisioningStateValues() []ProvisioningState {
	return []ProvisioningState{
		ProvisioningStateCanceled,
		ProvisioningStateCreating,
		ProvisioningStateDeleting,
		ProvisioningStateFailed,
		ProvisioningStateSucceeded,
		ProvisioningStateUnknown,
		ProvisioningStateUpdating,
	}
}

// ProvisioningStatus - The current deployment state of schedule.
type ProvisioningStatus string

const (
	ProvisioningStatusCompleted    ProvisioningStatus = "Completed"
	ProvisioningStatusFailed       ProvisioningStatus = "Failed"
	ProvisioningStatusProvisioning ProvisioningStatus = "Provisioning"
)

// PossibleProvisioningStatusValues returns the possible values for the ProvisioningStatus const type.
func PossibleProvisioningStatusValues() []ProvisioningStatus {
	return []ProvisioningStatus{
		ProvisioningStatusCompleted,
		ProvisioningStatusFailed,
		ProvisioningStatusProvisioning,
	}
}

// PublicNetworkAccess - Whether requests from Public Network are allowed.
type PublicNetworkAccess string

const (
	PublicNetworkAccessDisabled PublicNetworkAccess = "Disabled"
	PublicNetworkAccessEnabled  PublicNetworkAccess = "Enabled"
)

// PossiblePublicNetworkAccessValues returns the possible values for the PublicNetworkAccess const type.
func PossiblePublicNetworkAccessValues() []PublicNetworkAccess {
	return []PublicNetworkAccess{
		PublicNetworkAccessDisabled,
		PublicNetworkAccessEnabled,
	}
}

// PublicNetworkAccessType - Enum to determine whether PublicNetworkAccess is Enabled or Disabled.
type PublicNetworkAccessType string

const (
	PublicNetworkAccessTypeDisabled PublicNetworkAccessType = "Disabled"
	PublicNetworkAccessTypeEnabled  PublicNetworkAccessType = "Enabled"
)

// PossiblePublicNetworkAccessTypeValues returns the possible values for the PublicNetworkAccessType const type.
func PossiblePublicNetworkAccessTypeValues() []PublicNetworkAccessType {
	return []PublicNetworkAccessType{
		PublicNetworkAccessTypeDisabled,
		PublicNetworkAccessTypeEnabled,
	}
}

// QuotaUnit - An enum describing the unit of quota measurement.
type QuotaUnit string

const (
	QuotaUnitCount QuotaUnit = "Count"
)

// PossibleQuotaUnitValues returns the possible values for the QuotaUnit const type.
func PossibleQuotaUnitValues() []QuotaUnit {
	return []QuotaUnit{
		QuotaUnitCount,
	}
}

// RandomSamplingAlgorithmRule - The specific type of random algorithm
type RandomSamplingAlgorithmRule string

const (
	RandomSamplingAlgorithmRuleRandom RandomSamplingAlgorithmRule = "Random"
	RandomSamplingAlgorithmRuleSobol  RandomSamplingAlgorithmRule = "Sobol"
)

// PossibleRandomSamplingAlgorithmRuleValues returns the possible values for the RandomSamplingAlgorithmRule const type.
func PossibleRandomSamplingAlgorithmRuleValues() []RandomSamplingAlgorithmRule {
	return []RandomSamplingAlgorithmRule{
		RandomSamplingAlgorithmRuleRandom,
		RandomSamplingAlgorithmRuleSobol,
	}
}

// RecurrenceFrequency - Enum to describe the frequency of a recurrence schedule
type RecurrenceFrequency string

const (
	// RecurrenceFrequencyDay - Day frequency
	RecurrenceFrequencyDay RecurrenceFrequency = "Day"
	// RecurrenceFrequencyHour - Hour frequency
	RecurrenceFrequencyHour RecurrenceFrequency = "Hour"
	// RecurrenceFrequencyMinute - Minute frequency
	RecurrenceFrequencyMinute RecurrenceFrequency = "Minute"
	// RecurrenceFrequencyMonth - Month frequency
	RecurrenceFrequencyMonth RecurrenceFrequency = "Month"
	// RecurrenceFrequencyWeek - Week frequency
	RecurrenceFrequencyWeek RecurrenceFrequency = "Week"
)

// PossibleRecurrenceFrequencyValues returns the possible values for the RecurrenceFrequency const type.
func PossibleRecurrenceFrequencyValues() []RecurrenceFrequency {
	return []RecurrenceFrequency{
		RecurrenceFrequencyDay,
		RecurrenceFrequencyHour,
		RecurrenceFrequencyMinute,
		RecurrenceFrequencyMonth,
		RecurrenceFrequencyWeek,
	}
}

// ReferenceType - Enum to determine which reference method to use for an asset.
type ReferenceType string

const (
	ReferenceTypeDataPath   ReferenceType = "DataPath"
	ReferenceTypeID         ReferenceType = "Id"
	ReferenceTypeOutputPath ReferenceType = "OutputPath"
)

// PossibleReferenceTypeValues returns the possible values for the ReferenceType const type.
func PossibleReferenceTypeValues() []ReferenceType {
	return []ReferenceType{
		ReferenceTypeDataPath,
		ReferenceTypeID,
		ReferenceTypeOutputPath,
	}
}

// RegressionModels - Enum for all Regression models supported by AutoML.
type RegressionModels string

const (
	// RegressionModelsDecisionTree - Decision Trees are a non-parametric supervised learning method used for both classification
	// and regression tasks.
	// The goal is to create a model that predicts the value of a target variable by learning simple decision rules inferred from
	// the data features.
	RegressionModelsDecisionTree RegressionModels = "DecisionTree"
	// RegressionModelsElasticNet - Elastic net is a popular type of regularized linear regression that combines two popular penalties,
	// specifically the L1 and L2 penalty functions.
	RegressionModelsElasticNet RegressionModels = "ElasticNet"
	// RegressionModelsExtremeRandomTrees - Extreme Trees is an ensemble machine learning algorithm that combines the predictions
	// from many decision trees. It is related to the widely used random forest algorithm.
	RegressionModelsExtremeRandomTrees RegressionModels = "ExtremeRandomTrees"
	// RegressionModelsGradientBoosting - The technique of transiting week learners into a strong learner is called Boosting.
	// The gradient boosting algorithm process works on this theory of execution.
	RegressionModelsGradientBoosting RegressionModels = "GradientBoosting"
	// RegressionModelsKNN - K-nearest neighbors (KNN) algorithm uses 'feature similarity' to predict the values of new datapoints
	// which further means that the new data point will be assigned a value based on how closely it matches the points in the
	// training set.
	RegressionModelsKNN RegressionModels = "KNN"
	// RegressionModelsLassoLars - Lasso model fit with Least Angle Regression a.k.a. Lars. It is a Linear Model trained with
	// an L1 prior as regularizer.
	RegressionModelsLassoLars RegressionModels = "LassoLars"
	// RegressionModelsLightGBM - LightGBM is a gradient boosting framework that uses tree based learning algorithms.
	RegressionModelsLightGBM RegressionModels = "LightGBM"
	// RegressionModelsRandomForest - Random forest is a supervised learning algorithm.
	// The "forest" it builds, is an ensemble of decision trees, usually trained with the “bagging” method.
	// The general idea of the bagging method is that a combination of learning models increases the overall result.
	RegressionModelsRandomForest RegressionModels = "RandomForest"
	// RegressionModelsSGD - SGD: Stochastic gradient descent is an optimization algorithm often used in machine learning applications
	// to find the model parameters that correspond to the best fit between predicted and actual outputs.
	// It's an inexact but powerful technique.
	RegressionModelsSGD RegressionModels = "SGD"
	// RegressionModelsXGBoostRegressor - XGBoostRegressor: Extreme Gradient Boosting Regressor is a supervised machine learning
	// model using ensemble of base learners.
	RegressionModelsXGBoostRegressor RegressionModels = "XGBoostRegressor"
)

// PossibleRegressionModelsValues returns the possible values for the RegressionModels const type.
func PossibleRegressionModelsValues() []RegressionModels {
	return []RegressionModels{
		RegressionModelsDecisionTree,
		RegressionModelsElasticNet,
		RegressionModelsExtremeRandomTrees,
		RegressionModelsGradientBoosting,
		RegressionModelsKNN,
		RegressionModelsLassoLars,
		RegressionModelsLightGBM,
		RegressionModelsRandomForest,
		RegressionModelsSGD,
		RegressionModelsXGBoostRegressor,
	}
}

// RegressionPrimaryMetrics - Primary metrics for Regression task.
type RegressionPrimaryMetrics string

const (
	// RegressionPrimaryMetricsNormalizedMeanAbsoluteError - The Normalized Mean Absolute Error (NMAE) is a validation metric
	// to compare the Mean Absolute Error (MAE) of (time) series with different scales.
	RegressionPrimaryMetricsNormalizedMeanAbsoluteError RegressionPrimaryMetrics = "NormalizedMeanAbsoluteError"
	// RegressionPrimaryMetricsNormalizedRootMeanSquaredError - The Normalized Root Mean Squared Error (NRMSE) the RMSE facilitates
	// the comparison between models with different scales.
	RegressionPrimaryMetricsNormalizedRootMeanSquaredError RegressionPrimaryMetrics = "NormalizedRootMeanSquaredError"
	// RegressionPrimaryMetricsR2Score - The R2 score is one of the performance evaluation measures for forecasting-based machine
	// learning models.
	RegressionPrimaryMetricsR2Score RegressionPrimaryMetrics = "R2Score"
	// RegressionPrimaryMetricsSpearmanCorrelation - The Spearman's rank coefficient of correlation is a nonparametric measure
	// of rank correlation.
	RegressionPrimaryMetricsSpearmanCorrelation RegressionPrimaryMetrics = "SpearmanCorrelation"
)

// PossibleRegressionPrimaryMetricsValues returns the possible values for the RegressionPrimaryMetrics const type.
func PossibleRegressionPrimaryMetricsValues() []RegressionPrimaryMetrics {
	return []RegressionPrimaryMetrics{
		RegressionPrimaryMetricsNormalizedMeanAbsoluteError,
		RegressionPrimaryMetricsNormalizedRootMeanSquaredError,
		RegressionPrimaryMetricsR2Score,
		RegressionPrimaryMetricsSpearmanCorrelation,
	}
}

// RemoteLoginPortPublicAccess - State of the public SSH port. Possible values are: Disabled - Indicates that the public ssh
// port is closed on all nodes of the cluster. Enabled - Indicates that the public ssh port is open on all
// nodes of the cluster. NotSpecified - Indicates that the public ssh port is closed on all nodes of the cluster if VNet is
// defined, else is open all public nodes. It can be default only during cluster
// creation time, after creation it will be either enabled or disabled.
type RemoteLoginPortPublicAccess string

const (
	RemoteLoginPortPublicAccessDisabled     RemoteLoginPortPublicAccess = "Disabled"
	RemoteLoginPortPublicAccessEnabled      RemoteLoginPortPublicAccess = "Enabled"
	RemoteLoginPortPublicAccessNotSpecified RemoteLoginPortPublicAccess = "NotSpecified"
)

// PossibleRemoteLoginPortPublicAccessValues returns the possible values for the RemoteLoginPortPublicAccess const type.
func PossibleRemoteLoginPortPublicAccessValues() []RemoteLoginPortPublicAccess {
	return []RemoteLoginPortPublicAccess{
		RemoteLoginPortPublicAccessDisabled,
		RemoteLoginPortPublicAccessEnabled,
		RemoteLoginPortPublicAccessNotSpecified,
	}
}

type RollingRateType string

const (
	RollingRateTypeDay    RollingRateType = "Day"
	RollingRateTypeHour   RollingRateType = "Hour"
	RollingRateTypeMinute RollingRateType = "Minute"
	RollingRateTypeMonth  RollingRateType = "Month"
	RollingRateTypeYear   RollingRateType = "Year"
)

// PossibleRollingRateTypeValues returns the possible values for the RollingRateType const type.
func PossibleRollingRateTypeValues() []RollingRateType {
	return []RollingRateType{
		RollingRateTypeDay,
		RollingRateTypeHour,
		RollingRateTypeMinute,
		RollingRateTypeMonth,
		RollingRateTypeYear,
	}
}

// RuleAction - The action enum for networking rule.
type RuleAction string

const (
	RuleActionAllow RuleAction = "Allow"
	RuleActionDeny  RuleAction = "Deny"
)

// PossibleRuleActionValues returns the possible values for the RuleAction const type.
func PossibleRuleActionValues() []RuleAction {
	return []RuleAction{
		RuleActionAllow,
		RuleActionDeny,
	}
}

// RuleCategory - Category of a managed network Outbound Rule of a machine learning workspace.
type RuleCategory string

const (
	RuleCategoryDependency  RuleCategory = "Dependency"
	RuleCategoryRecommended RuleCategory = "Recommended"
	RuleCategoryRequired    RuleCategory = "Required"
	RuleCategoryUserDefined RuleCategory = "UserDefined"
)

// PossibleRuleCategoryValues returns the possible values for the RuleCategory const type.
func PossibleRuleCategoryValues() []RuleCategory {
	return []RuleCategory{
		RuleCategoryDependency,
		RuleCategoryRecommended,
		RuleCategoryRequired,
		RuleCategoryUserDefined,
	}
}

// RuleStatus - Type of a managed network Outbound Rule of a machine learning workspace.
type RuleStatus string

const (
	RuleStatusActive   RuleStatus = "Active"
	RuleStatusInactive RuleStatus = "Inactive"
)

// PossibleRuleStatusValues returns the possible values for the RuleStatus const type.
func PossibleRuleStatusValues() []RuleStatus {
	return []RuleStatus{
		RuleStatusActive,
		RuleStatusInactive,
	}
}

// RuleType - Type of a managed network Outbound Rule of a machine learning workspace.
type RuleType string

const (
	RuleTypeFQDN            RuleType = "FQDN"
	RuleTypePrivateEndpoint RuleType = "PrivateEndpoint"
	RuleTypeServiceTag      RuleType = "ServiceTag"
)

// PossibleRuleTypeValues returns the possible values for the RuleType const type.
func PossibleRuleTypeValues() []RuleType {
	return []RuleType{
		RuleTypeFQDN,
		RuleTypePrivateEndpoint,
		RuleTypeServiceTag,
	}
}

// SKUScaleType - Node scaling setting for the compute sku.
type SKUScaleType string

const (
	// SKUScaleTypeAutomatic - Automatically scales node count.
	SKUScaleTypeAutomatic SKUScaleType = "Automatic"
	// SKUScaleTypeManual - Node count scaled upon user request.
	SKUScaleTypeManual SKUScaleType = "Manual"
	// SKUScaleTypeNone - Fixed set of nodes.
	SKUScaleTypeNone SKUScaleType = "None"
)

// PossibleSKUScaleTypeValues returns the possible values for the SKUScaleType const type.
func PossibleSKUScaleTypeValues() []SKUScaleType {
	return []SKUScaleType{
		SKUScaleTypeAutomatic,
		SKUScaleTypeManual,
		SKUScaleTypeNone,
	}
}

// SKUTier - This field is required to be implemented by the Resource Provider if the service has more than one tier, but
// is not required on a PUT.
type SKUTier string

const (
	SKUTierBasic    SKUTier = "Basic"
	SKUTierFree     SKUTier = "Free"
	SKUTierPremium  SKUTier = "Premium"
	SKUTierStandard SKUTier = "Standard"
)

// PossibleSKUTierValues returns the possible values for the SKUTier const type.
func PossibleSKUTierValues() []SKUTier {
	return []SKUTier{
		SKUTierBasic,
		SKUTierFree,
		SKUTierPremium,
		SKUTierStandard,
	}
}

// SSHPublicAccess - State of the public SSH port. Possible values are: Disabled - Indicates that the public ssh port is closed
// on this instance. Enabled - Indicates that the public ssh port is open and accessible
// according to the VNet/subnet policy if applicable.
type SSHPublicAccess string

const (
	SSHPublicAccessDisabled SSHPublicAccess = "Disabled"
	SSHPublicAccessEnabled  SSHPublicAccess = "Enabled"
)

// PossibleSSHPublicAccessValues returns the possible values for the SSHPublicAccess const type.
func PossibleSSHPublicAccessValues() []SSHPublicAccess {
	return []SSHPublicAccess{
		SSHPublicAccessDisabled,
		SSHPublicAccessEnabled,
	}
}

// SSLConfigStatus - Enable or disable ssl for scoring
type SSLConfigStatus string

const (
	SSLConfigStatusAuto     SSLConfigStatus = "Auto"
	SSLConfigStatusDisabled SSLConfigStatus = "Disabled"
	SSLConfigStatusEnabled  SSLConfigStatus = "Enabled"
)

// PossibleSSLConfigStatusValues returns the possible values for the SSLConfigStatus const type.
func PossibleSSLConfigStatusValues() []SSLConfigStatus {
	return []SSLConfigStatus{
		SSLConfigStatusAuto,
		SSLConfigStatusDisabled,
		SSLConfigStatusEnabled,
	}
}

type SamplingAlgorithmType string

const (
	SamplingAlgorithmTypeBayesian SamplingAlgorithmType = "Bayesian"
	SamplingAlgorithmTypeGrid     SamplingAlgorithmType = "Grid"
	SamplingAlgorithmTypeRandom   SamplingAlgorithmType = "Random"
)

// PossibleSamplingAlgorithmTypeValues returns the possible values for the SamplingAlgorithmType const type.
func PossibleSamplingAlgorithmTypeValues() []SamplingAlgorithmType {
	return []SamplingAlgorithmType{
		SamplingAlgorithmTypeBayesian,
		SamplingAlgorithmTypeGrid,
		SamplingAlgorithmTypeRandom,
	}
}

type ScaleType string

const (
	ScaleTypeDefault           ScaleType = "Default"
	ScaleTypeTargetUtilization ScaleType = "TargetUtilization"
)

// PossibleScaleTypeValues returns the possible values for the ScaleType const type.
func PossibleScaleTypeValues() []ScaleType {
	return []ScaleType{
		ScaleTypeDefault,
		ScaleTypeTargetUtilization,
	}
}

type ScheduleActionType string

const (
	ScheduleActionTypeCreateJob           ScheduleActionType = "CreateJob"
	ScheduleActionTypeCreateMonitor       ScheduleActionType = "CreateMonitor"
	ScheduleActionTypeInvokeBatchEndpoint ScheduleActionType = "InvokeBatchEndpoint"
)

// PossibleScheduleActionTypeValues returns the possible values for the ScheduleActionType const type.
func PossibleScheduleActionTypeValues() []ScheduleActionType {
	return []ScheduleActionType{
		ScheduleActionTypeCreateJob,
		ScheduleActionTypeCreateMonitor,
		ScheduleActionTypeInvokeBatchEndpoint,
	}
}

type ScheduleListViewType string

const (
	ScheduleListViewTypeAll          ScheduleListViewType = "All"
	ScheduleListViewTypeDisabledOnly ScheduleListViewType = "DisabledOnly"
	ScheduleListViewTypeEnabledOnly  ScheduleListViewType = "EnabledOnly"
)

// PossibleScheduleListViewTypeValues returns the possible values for the ScheduleListViewType const type.
func PossibleScheduleListViewTypeValues() []ScheduleListViewType {
	return []ScheduleListViewType{
		ScheduleListViewTypeAll,
		ScheduleListViewTypeDisabledOnly,
		ScheduleListViewTypeEnabledOnly,
	}
}

// ScheduleProvisioningState - The current deployment state of schedule.
type ScheduleProvisioningState string

const (
	ScheduleProvisioningStateCompleted    ScheduleProvisioningState = "Completed"
	ScheduleProvisioningStateFailed       ScheduleProvisioningState = "Failed"
	ScheduleProvisioningStateProvisioning ScheduleProvisioningState = "Provisioning"
)

// PossibleScheduleProvisioningStateValues returns the possible values for the ScheduleProvisioningState const type.
func PossibleScheduleProvisioningStateValues() []ScheduleProvisioningState {
	return []ScheduleProvisioningState{
		ScheduleProvisioningStateCompleted,
		ScheduleProvisioningStateFailed,
		ScheduleProvisioningStateProvisioning,
	}
}

type ScheduleProvisioningStatus string

const (
	ScheduleProvisioningStatusCanceled  ScheduleProvisioningStatus = "Canceled"
	ScheduleProvisioningStatusCreating  ScheduleProvisioningStatus = "Creating"
	ScheduleProvisioningStatusDeleting  ScheduleProvisioningStatus = "Deleting"
	ScheduleProvisioningStatusFailed    ScheduleProvisioningStatus = "Failed"
	ScheduleProvisioningStatusSucceeded ScheduleProvisioningStatus = "Succeeded"
	ScheduleProvisioningStatusUpdating  ScheduleProvisioningStatus = "Updating"
)

// PossibleScheduleProvisioningStatusValues returns the possible values for the ScheduleProvisioningStatus const type.
func PossibleScheduleProvisioningStatusValues() []ScheduleProvisioningStatus {
	return []ScheduleProvisioningStatus{
		ScheduleProvisioningStatusCanceled,
		ScheduleProvisioningStatusCreating,
		ScheduleProvisioningStatusDeleting,
		ScheduleProvisioningStatusFailed,
		ScheduleProvisioningStatusSucceeded,
		ScheduleProvisioningStatusUpdating,
	}
}

// ScheduleStatus - Is the schedule enabled or disabled?
type ScheduleStatus string

const (
	ScheduleStatusDisabled ScheduleStatus = "Disabled"
	ScheduleStatusEnabled  ScheduleStatus = "Enabled"
)

// PossibleScheduleStatusValues returns the possible values for the ScheduleStatus const type.
func PossibleScheduleStatusValues() []ScheduleStatus {
	return []ScheduleStatus{
		ScheduleStatusDisabled,
		ScheduleStatusEnabled,
	}
}

// SeasonalityMode - Forecasting seasonality mode.
type SeasonalityMode string

const (
	// SeasonalityModeAuto - Seasonality to be determined automatically.
	SeasonalityModeAuto SeasonalityMode = "Auto"
	// SeasonalityModeCustom - Use the custom seasonality value.
	SeasonalityModeCustom SeasonalityMode = "Custom"
)

// PossibleSeasonalityModeValues returns the possible values for the SeasonalityMode const type.
func PossibleSeasonalityModeValues() []SeasonalityMode {
	return []SeasonalityMode{
		SeasonalityModeAuto,
		SeasonalityModeCustom,
	}
}

// SecretsType - Enum to determine the datastore secrets type.
type SecretsType string

const (
	SecretsTypeAccountKey       SecretsType = "AccountKey"
	SecretsTypeCertificate      SecretsType = "Certificate"
	SecretsTypeSas              SecretsType = "Sas"
	SecretsTypeServicePrincipal SecretsType = "ServicePrincipal"
)

// PossibleSecretsTypeValues returns the possible values for the SecretsType const type.
func PossibleSecretsTypeValues() []SecretsType {
	return []SecretsType{
		SecretsTypeAccountKey,
		SecretsTypeCertificate,
		SecretsTypeSas,
		SecretsTypeServicePrincipal,
	}
}

// ServerlessEndpointState - State of the Serverless Endpoint.
type ServerlessEndpointState string

const (
	ServerlessEndpointStateCreating       ServerlessEndpointState = "Creating"
	ServerlessEndpointStateCreationFailed ServerlessEndpointState = "CreationFailed"
	ServerlessEndpointStateDeleting       ServerlessEndpointState = "Deleting"
	ServerlessEndpointStateDeletionFailed ServerlessEndpointState = "DeletionFailed"
	ServerlessEndpointStateOnline         ServerlessEndpointState = "Online"
	ServerlessEndpointStateReinstating    ServerlessEndpointState = "Reinstating"
	ServerlessEndpointStateSuspended      ServerlessEndpointState = "Suspended"
	ServerlessEndpointStateSuspending     ServerlessEndpointState = "Suspending"
	ServerlessEndpointStateUnknown        ServerlessEndpointState = "Unknown"
)

// PossibleServerlessEndpointStateValues returns the possible values for the ServerlessEndpointState const type.
func PossibleServerlessEndpointStateValues() []ServerlessEndpointState {
	return []ServerlessEndpointState{
		ServerlessEndpointStateCreating,
		ServerlessEndpointStateCreationFailed,
		ServerlessEndpointStateDeleting,
		ServerlessEndpointStateDeletionFailed,
		ServerlessEndpointStateOnline,
		ServerlessEndpointStateReinstating,
		ServerlessEndpointStateSuspended,
		ServerlessEndpointStateSuspending,
		ServerlessEndpointStateUnknown,
	}
}

type ServerlessInferenceEndpointAuthMode string

const (
	ServerlessInferenceEndpointAuthModeKey ServerlessInferenceEndpointAuthMode = "Key"
)

// PossibleServerlessInferenceEndpointAuthModeValues returns the possible values for the ServerlessInferenceEndpointAuthMode const type.
func PossibleServerlessInferenceEndpointAuthModeValues() []ServerlessInferenceEndpointAuthMode {
	return []ServerlessInferenceEndpointAuthMode{
		ServerlessInferenceEndpointAuthModeKey,
	}
}

type ServiceDataAccessAuthIdentity string

const (
	// ServiceDataAccessAuthIdentityNone - Do not use any identity for service data access.
	ServiceDataAccessAuthIdentityNone ServiceDataAccessAuthIdentity = "None"
	// ServiceDataAccessAuthIdentityWorkspaceSystemAssignedIdentity - Use the system assigned managed identity of the Workspace
	// to authenticate service data access.
	ServiceDataAccessAuthIdentityWorkspaceSystemAssignedIdentity ServiceDataAccessAuthIdentity = "WorkspaceSystemAssignedIdentity"
	// ServiceDataAccessAuthIdentityWorkspaceUserAssignedIdentity - Use the user assigned managed identity of the Workspace to
	// authenticate service data access.
	ServiceDataAccessAuthIdentityWorkspaceUserAssignedIdentity ServiceDataAccessAuthIdentity = "WorkspaceUserAssignedIdentity"
)

// PossibleServiceDataAccessAuthIdentityValues returns the possible values for the ServiceDataAccessAuthIdentity const type.
func PossibleServiceDataAccessAuthIdentityValues() []ServiceDataAccessAuthIdentity {
	return []ServiceDataAccessAuthIdentity{
		ServiceDataAccessAuthIdentityNone,
		ServiceDataAccessAuthIdentityWorkspaceSystemAssignedIdentity,
		ServiceDataAccessAuthIdentityWorkspaceUserAssignedIdentity,
	}
}

// ShortSeriesHandlingConfiguration - The parameter defining how if AutoML should handle short time series.
type ShortSeriesHandlingConfiguration string

const (
	// ShortSeriesHandlingConfigurationAuto - Short series will be padded if there are no long series, otherwise short series
	// will be dropped.
	ShortSeriesHandlingConfigurationAuto ShortSeriesHandlingConfiguration = "Auto"
	// ShortSeriesHandlingConfigurationDrop - All the short series will be dropped.
	ShortSeriesHandlingConfigurationDrop ShortSeriesHandlingConfiguration = "Drop"
	// ShortSeriesHandlingConfigurationNone - Represents no/null value.
	ShortSeriesHandlingConfigurationNone ShortSeriesHandlingConfiguration = "None"
	// ShortSeriesHandlingConfigurationPad - All the short series will be padded.
	ShortSeriesHandlingConfigurationPad ShortSeriesHandlingConfiguration = "Pad"
)

// PossibleShortSeriesHandlingConfigurationValues returns the possible values for the ShortSeriesHandlingConfiguration const type.
func PossibleShortSeriesHandlingConfigurationValues() []ShortSeriesHandlingConfiguration {
	return []ShortSeriesHandlingConfiguration{
		ShortSeriesHandlingConfigurationAuto,
		ShortSeriesHandlingConfigurationDrop,
		ShortSeriesHandlingConfigurationNone,
		ShortSeriesHandlingConfigurationPad,
	}
}

// SourceType - Data source type.
type SourceType string

const (
	SourceTypeDataset   SourceType = "Dataset"
	SourceTypeDatastore SourceType = "Datastore"
	SourceTypeURI       SourceType = "URI"
)

// PossibleSourceTypeValues returns the possible values for the SourceType const type.
func PossibleSourceTypeValues() []SourceType {
	return []SourceType{
		SourceTypeDataset,
		SourceTypeDatastore,
		SourceTypeURI,
	}
}

type SparkJobEntryType string

const (
	SparkJobEntryTypeSparkJobPythonEntry SparkJobEntryType = "SparkJobPythonEntry"
	SparkJobEntryTypeSparkJobScalaEntry  SparkJobEntryType = "SparkJobScalaEntry"
)

// PossibleSparkJobEntryTypeValues returns the possible values for the SparkJobEntryType const type.
func PossibleSparkJobEntryTypeValues() []SparkJobEntryType {
	return []SparkJobEntryType{
		SparkJobEntryTypeSparkJobPythonEntry,
		SparkJobEntryTypeSparkJobScalaEntry,
	}
}

// StackMetaLearnerType - The meta-learner is a model trained on the output of the individual heterogeneous models. Default
// meta-learners are LogisticRegression for classification tasks (or LogisticRegressionCV if
// cross-validation is enabled) and ElasticNet for regression/forecasting tasks (or ElasticNetCV if cross-validation is enabled).
// This parameter can be one of the following strings: LogisticRegression,
// LogisticRegressionCV, LightGBMClassifier, ElasticNet, ElasticNetCV, LightGBMRegressor, or LinearRegression
type StackMetaLearnerType string

const (
	// StackMetaLearnerTypeElasticNet - Default meta-learners are LogisticRegression for regression task.
	StackMetaLearnerTypeElasticNet StackMetaLearnerType = "ElasticNet"
	// StackMetaLearnerTypeElasticNetCV - Default meta-learners are LogisticRegression for regression task when CV is on.
	StackMetaLearnerTypeElasticNetCV       StackMetaLearnerType = "ElasticNetCV"
	StackMetaLearnerTypeLightGBMClassifier StackMetaLearnerType = "LightGBMClassifier"
	StackMetaLearnerTypeLightGBMRegressor  StackMetaLearnerType = "LightGBMRegressor"
	StackMetaLearnerTypeLinearRegression   StackMetaLearnerType = "LinearRegression"
	// StackMetaLearnerTypeLogisticRegression - Default meta-learners are LogisticRegression for classification tasks.
	StackMetaLearnerTypeLogisticRegression StackMetaLearnerType = "LogisticRegression"
	// StackMetaLearnerTypeLogisticRegressionCV - Default meta-learners are LogisticRegression for classification task when CV
	// is on.
	StackMetaLearnerTypeLogisticRegressionCV StackMetaLearnerType = "LogisticRegressionCV"
	StackMetaLearnerTypeNone                 StackMetaLearnerType = "None"
)

// PossibleStackMetaLearnerTypeValues returns the possible values for the StackMetaLearnerType const type.
func PossibleStackMetaLearnerTypeValues() []StackMetaLearnerType {
	return []StackMetaLearnerType{
		StackMetaLearnerTypeElasticNet,
		StackMetaLearnerTypeElasticNetCV,
		StackMetaLearnerTypeLightGBMClassifier,
		StackMetaLearnerTypeLightGBMRegressor,
		StackMetaLearnerTypeLinearRegression,
		StackMetaLearnerTypeLogisticRegression,
		StackMetaLearnerTypeLogisticRegressionCV,
		StackMetaLearnerTypeNone,
	}
}

// Status - Status of update workspace quota.
type Status string

const (
	StatusFailure                              Status = "Failure"
	StatusInvalidQuotaBelowClusterMinimum      Status = "InvalidQuotaBelowClusterMinimum"
	StatusInvalidQuotaExceedsSubscriptionLimit Status = "InvalidQuotaExceedsSubscriptionLimit"
	StatusInvalidVMFamilyName                  Status = "InvalidVMFamilyName"
	StatusOperationNotEnabledForRegion         Status = "OperationNotEnabledForRegion"
	StatusOperationNotSupportedForSKU          Status = "OperationNotSupportedForSku"
	StatusSuccess                              Status = "Success"
	StatusUndefined                            Status = "Undefined"
)

// PossibleStatusValues returns the possible values for the Status const type.
func PossibleStatusValues() []Status {
	return []Status{
		StatusFailure,
		StatusInvalidQuotaBelowClusterMinimum,
		StatusInvalidQuotaExceedsSubscriptionLimit,
		StatusInvalidVMFamilyName,
		StatusOperationNotEnabledForRegion,
		StatusOperationNotSupportedForSKU,
		StatusSuccess,
		StatusUndefined,
	}
}

// StochasticOptimizer - Stochastic optimizer for image models.
type StochasticOptimizer string

const (
	// StochasticOptimizerAdam - Adam is algorithm the optimizes stochastic objective functions based on adaptive estimates of
	// moments
	StochasticOptimizerAdam StochasticOptimizer = "Adam"
	// StochasticOptimizerAdamw - AdamW is a variant of the optimizer Adam that has an improved implementation of weight decay.
	StochasticOptimizerAdamw StochasticOptimizer = "Adamw"
	// StochasticOptimizerNone - No optimizer selected.
	StochasticOptimizerNone StochasticOptimizer = "None"
	// StochasticOptimizerSgd - Stochastic Gradient Descent optimizer.
	StochasticOptimizerSgd StochasticOptimizer = "Sgd"
)

// PossibleStochasticOptimizerValues returns the possible values for the StochasticOptimizer const type.
func PossibleStochasticOptimizerValues() []StochasticOptimizer {
	return []StochasticOptimizer{
		StochasticOptimizerAdam,
		StochasticOptimizerAdamw,
		StochasticOptimizerNone,
		StochasticOptimizerSgd,
	}
}

// StorageAccountType - type of this storage account.
type StorageAccountType string

const (
	StorageAccountTypePremiumLRS  StorageAccountType = "Premium_LRS"
	StorageAccountTypeStandardLRS StorageAccountType = "Standard_LRS"
)

// PossibleStorageAccountTypeValues returns the possible values for the StorageAccountType const type.
func PossibleStorageAccountTypeValues() []StorageAccountType {
	return []StorageAccountType{
		StorageAccountTypePremiumLRS,
		StorageAccountTypeStandardLRS,
	}
}

// TargetAggregationFunction - Target aggregate function.
type TargetAggregationFunction string

const (
	TargetAggregationFunctionMax  TargetAggregationFunction = "Max"
	TargetAggregationFunctionMean TargetAggregationFunction = "Mean"
	TargetAggregationFunctionMin  TargetAggregationFunction = "Min"
	// TargetAggregationFunctionNone - Represent no value set.
	TargetAggregationFunctionNone TargetAggregationFunction = "None"
	TargetAggregationFunctionSum  TargetAggregationFunction = "Sum"
)

// PossibleTargetAggregationFunctionValues returns the possible values for the TargetAggregationFunction const type.
func PossibleTargetAggregationFunctionValues() []TargetAggregationFunction {
	return []TargetAggregationFunction{
		TargetAggregationFunctionMax,
		TargetAggregationFunctionMean,
		TargetAggregationFunctionMin,
		TargetAggregationFunctionNone,
		TargetAggregationFunctionSum,
	}
}

// TargetLagsMode - Target lags selection modes.
type TargetLagsMode string

const (
	// TargetLagsModeAuto - Target lags to be determined automatically.
	TargetLagsModeAuto TargetLagsMode = "Auto"
	// TargetLagsModeCustom - Use the custom target lags.
	TargetLagsModeCustom TargetLagsMode = "Custom"
)

// PossibleTargetLagsModeValues returns the possible values for the TargetLagsMode const type.
func PossibleTargetLagsModeValues() []TargetLagsMode {
	return []TargetLagsMode{
		TargetLagsModeAuto,
		TargetLagsModeCustom,
	}
}

// TargetRollingWindowSizeMode - Target rolling windows size mode.
type TargetRollingWindowSizeMode string

const (
	// TargetRollingWindowSizeModeAuto - Determine rolling windows size automatically.
	TargetRollingWindowSizeModeAuto TargetRollingWindowSizeMode = "Auto"
	// TargetRollingWindowSizeModeCustom - Use the specified rolling window size.
	TargetRollingWindowSizeModeCustom TargetRollingWindowSizeMode = "Custom"
)

// PossibleTargetRollingWindowSizeModeValues returns the possible values for the TargetRollingWindowSizeMode const type.
func PossibleTargetRollingWindowSizeModeValues() []TargetRollingWindowSizeMode {
	return []TargetRollingWindowSizeMode{
		TargetRollingWindowSizeModeAuto,
		TargetRollingWindowSizeModeCustom,
	}
}

// TaskType - AutoMLJob Task type.
type TaskType string

const (
	// TaskTypeClassification - Classification in machine learning and statistics is a supervised learning approach in which
	// the computer program learns from the data given to it and make new observations or classifications.
	TaskTypeClassification TaskType = "Classification"
	// TaskTypeForecasting - Forecasting is a special kind of regression task that deals with time-series data and creates forecasting
	// model
	// that can be used to predict the near future values based on the inputs.
	TaskTypeForecasting TaskType = "Forecasting"
	// TaskTypeImageClassification - Image Classification. Multi-class image classification is used when an image is classified
	// with only a single label
	// from a set of classes - e.g. each image is classified as either an image of a 'cat' or a 'dog' or a 'duck'.
	TaskTypeImageClassification TaskType = "ImageClassification"
	// TaskTypeImageClassificationMultilabel - Image Classification Multilabel. Multi-label image classification is used when
	// an image could have one or more labels
	// from a set of labels - e.g. an image could be labeled with both 'cat' and 'dog'.
	TaskTypeImageClassificationMultilabel TaskType = "ImageClassificationMultilabel"
	// TaskTypeImageInstanceSegmentation - Image Instance Segmentation. Instance segmentation is used to identify objects in an
	// image at the pixel level,
	// drawing a polygon around each object in the image.
	TaskTypeImageInstanceSegmentation TaskType = "ImageInstanceSegmentation"
	// TaskTypeImageObjectDetection - Image Object Detection. Object detection is used to identify objects in an image and locate
	// each object with a
	// bounding box e.g. locate all dogs and cats in an image and draw a bounding box around each.
	TaskTypeImageObjectDetection TaskType = "ImageObjectDetection"
	// TaskTypeRegression - Regression means to predict the value using the input data. Regression models are used to predict
	// a continuous value.
	TaskTypeRegression TaskType = "Regression"
	// TaskTypeTextClassification - Text classification (also known as text tagging or text categorization) is the process of
	// sorting texts into categories.
	// Categories are mutually exclusive.
	TaskTypeTextClassification TaskType = "TextClassification"
	// TaskTypeTextClassificationMultilabel - Multilabel classification task assigns each sample to a group (zero or more) of
	// target labels.
	TaskTypeTextClassificationMultilabel TaskType = "TextClassificationMultilabel"
	// TaskTypeTextNER - Text Named Entity Recognition a.k.a. TextNER.
	// Named Entity Recognition (NER) is the ability to take free-form text and identify the occurrences of entities such as people,
	// locations, organizations, and more.
	TaskTypeTextNER TaskType = "TextNER"
)

// PossibleTaskTypeValues returns the possible values for the TaskType const type.
func PossibleTaskTypeValues() []TaskType {
	return []TaskType{
		TaskTypeClassification,
		TaskTypeForecasting,
		TaskTypeImageClassification,
		TaskTypeImageClassificationMultilabel,
		TaskTypeImageInstanceSegmentation,
		TaskTypeImageObjectDetection,
		TaskTypeRegression,
		TaskTypeTextClassification,
		TaskTypeTextClassificationMultilabel,
		TaskTypeTextNER,
	}
}

type TriggerType string

const (
	TriggerTypeCron       TriggerType = "Cron"
	TriggerTypeRecurrence TriggerType = "Recurrence"
)

// PossibleTriggerTypeValues returns the possible values for the TriggerType const type.
func PossibleTriggerTypeValues() []TriggerType {
	return []TriggerType{
		TriggerTypeCron,
		TriggerTypeRecurrence,
	}
}

type UnderlyingResourceAction string

const (
	UnderlyingResourceActionDelete UnderlyingResourceAction = "Delete"
	UnderlyingResourceActionDetach UnderlyingResourceAction = "Detach"
)

// PossibleUnderlyingResourceActionValues returns the possible values for the UnderlyingResourceAction const type.
func PossibleUnderlyingResourceActionValues() []UnderlyingResourceAction {
	return []UnderlyingResourceAction{
		UnderlyingResourceActionDelete,
		UnderlyingResourceActionDetach,
	}
}

// UnitOfMeasure - The unit of time measurement for the specified VM price. Example: OneHour
type UnitOfMeasure string

const (
	UnitOfMeasureOneHour UnitOfMeasure = "OneHour"
)

// PossibleUnitOfMeasureValues returns the possible values for the UnitOfMeasure const type.
func PossibleUnitOfMeasureValues() []UnitOfMeasure {
	return []UnitOfMeasure{
		UnitOfMeasureOneHour,
	}
}

// UsageUnit - An enum describing the unit of usage measurement.
type UsageUnit string

const (
	UsageUnitCount UsageUnit = "Count"
)

// PossibleUsageUnitValues returns the possible values for the UsageUnit const type.
func PossibleUsageUnitValues() []UsageUnit {
	return []UsageUnit{
		UsageUnitCount,
	}
}

// UseStl - Configure STL Decomposition of the time-series target column.
type UseStl string

const (
	// UseStlNone - No stl decomposition.
	UseStlNone        UseStl = "None"
	UseStlSeason      UseStl = "Season"
	UseStlSeasonTrend UseStl = "SeasonTrend"
)

// PossibleUseStlValues returns the possible values for the UseStl const type.
func PossibleUseStlValues() []UseStl {
	return []UseStl{
		UseStlNone,
		UseStlSeason,
		UseStlSeasonTrend,
	}
}

// VMPriceOSType - Operating system type used by the VM.
type VMPriceOSType string

const (
	VMPriceOSTypeLinux   VMPriceOSType = "Linux"
	VMPriceOSTypeWindows VMPriceOSType = "Windows"
)

// PossibleVMPriceOSTypeValues returns the possible values for the VMPriceOSType const type.
func PossibleVMPriceOSTypeValues() []VMPriceOSType {
	return []VMPriceOSType{
		VMPriceOSTypeLinux,
		VMPriceOSTypeWindows,
	}
}

// VMPriority - Virtual Machine priority
type VMPriority string

const (
	VMPriorityDedicated   VMPriority = "Dedicated"
	VMPriorityLowPriority VMPriority = "LowPriority"
)

// PossibleVMPriorityValues returns the possible values for the VMPriority const type.
func PossibleVMPriorityValues() []VMPriority {
	return []VMPriority{
		VMPriorityDedicated,
		VMPriorityLowPriority,
	}
}

// VMTier - The type of the VM.
type VMTier string

const (
	VMTierLowPriority VMTier = "LowPriority"
	VMTierSpot        VMTier = "Spot"
	VMTierStandard    VMTier = "Standard"
)

// PossibleVMTierValues returns the possible values for the VMTier const type.
func PossibleVMTierValues() []VMTier {
	return []VMTier{
		VMTierLowPriority,
		VMTierSpot,
		VMTierStandard,
	}
}

// ValidationMetricType - Metric computation method to use for validation metrics in image tasks.
type ValidationMetricType string

const (
	// ValidationMetricTypeCoco - Coco metric.
	ValidationMetricTypeCoco ValidationMetricType = "Coco"
	// ValidationMetricTypeCocoVoc - CocoVoc metric.
	ValidationMetricTypeCocoVoc ValidationMetricType = "CocoVoc"
	// ValidationMetricTypeNone - No metric.
	ValidationMetricTypeNone ValidationMetricType = "None"
	// ValidationMetricTypeVoc - Voc metric.
	ValidationMetricTypeVoc ValidationMetricType = "Voc"
)

// PossibleValidationMetricTypeValues returns the possible values for the ValidationMetricType const type.
func PossibleValidationMetricTypeValues() []ValidationMetricType {
	return []ValidationMetricType{
		ValidationMetricTypeCoco,
		ValidationMetricTypeCocoVoc,
		ValidationMetricTypeNone,
		ValidationMetricTypeVoc,
	}
}

// ValueFormat - format for the workspace connection value
type ValueFormat string

const (
	ValueFormatJSON ValueFormat = "JSON"
)

// PossibleValueFormatValues returns the possible values for the ValueFormat const type.
func PossibleValueFormatValues() []ValueFormat {
	return []ValueFormat{
		ValueFormatJSON,
	}
}

// VolumeDefinitionType - Type of Volume Definition. Possible Values: bind,volume,tmpfs,npipe
type VolumeDefinitionType string

const (
	VolumeDefinitionTypeBind   VolumeDefinitionType = "bind"
	VolumeDefinitionTypeNpipe  VolumeDefinitionType = "npipe"
	VolumeDefinitionTypeTmpfs  VolumeDefinitionType = "tmpfs"
	VolumeDefinitionTypeVolume VolumeDefinitionType = "volume"
)

// PossibleVolumeDefinitionTypeValues returns the possible values for the VolumeDefinitionType const type.
func PossibleVolumeDefinitionTypeValues() []VolumeDefinitionType {
	return []VolumeDefinitionType{
		VolumeDefinitionTypeBind,
		VolumeDefinitionTypeNpipe,
		VolumeDefinitionTypeTmpfs,
		VolumeDefinitionTypeVolume,
	}
}

// WebhookType - Enum to determine the webhook callback service type.
type WebhookType string

const (
	WebhookTypeAzureDevOps WebhookType = "AzureDevOps"
)

// PossibleWebhookTypeValues returns the possible values for the WebhookType const type.
func PossibleWebhookTypeValues() []WebhookType {
	return []WebhookType{
		WebhookTypeAzureDevOps,
	}
}

// WeekDay - Enum of weekday
type WeekDay string

const (
	// WeekDayFriday - Friday weekday
	WeekDayFriday WeekDay = "Friday"
	// WeekDayMonday - Monday weekday
	WeekDayMonday WeekDay = "Monday"
	// WeekDaySaturday - Saturday weekday
	WeekDaySaturday WeekDay = "Saturday"
	// WeekDaySunday - Sunday weekday
	WeekDaySunday WeekDay = "Sunday"
	// WeekDayThursday - Thursday weekday
	WeekDayThursday WeekDay = "Thursday"
	// WeekDayTuesday - Tuesday weekday
	WeekDayTuesday WeekDay = "Tuesday"
	// WeekDayWednesday - Wednesday weekday
	WeekDayWednesday WeekDay = "Wednesday"
)

// PossibleWeekDayValues returns the possible values for the WeekDay const type.
func PossibleWeekDayValues() []WeekDay {
	return []WeekDay{
		WeekDayFriday,
		WeekDayMonday,
		WeekDaySaturday,
		WeekDaySunday,
		WeekDayThursday,
		WeekDayTuesday,
		WeekDayWednesday,
	}
}
