machineLearningServices.json

{
  "swagger": "2.0",
  "info": {
    "title": "Azure Machine Learning Workspaces",
    "description": "These APIs allow end users to operate on Azure Machine Learning Workspace resources.",
    "version": "2020-05-01-preview"
  },
  "host": "management.azure.com",
  "schemes": [
    "https"
  ],
  "consumes": [
    "application/json"
  ],
  "produces": [
    "application/json"
  ],
  "security": [
    {
      "azure_auth": [
        "user_impersonation"
      ]
    }
  ],
  "securityDefinitions": {
    "azure_auth": {
      "type": "oauth2",
      "authorizationUrl": "https://login.microsoftonline.com/common/oauth2/authorize",
      "flow": "implicit",
      "description": "Azure Active Directory OAuth2 Flow.",
      "scopes": {
        "user_impersonation": "impersonate your user account"
      }
    }
  },
  "paths": {
    "/providers/Microsoft.MachineLearningServices/operations": {
      "get": {
        "tags": [
          "Operation"
        ],
        "description": "Lists all of the available Azure Machine Learning Workspaces REST API operations.",
        "operationId": "Operations_List",
        "parameters": [
          {
            "$ref": "#/parameters/APIVersionParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The request was successful; the request was well-formed and received properly.",
            "schema": {
              "$ref": "#/definitions/OperationListResult"
            }
          },
          "default": {
            "description": "Error response describing why the operation failed",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        },
        "x-ms-pageable": {
          "nextLinkName": null
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}": {
      "get": {
        "tags": [
          "Workspaces"
        ],
        "description": "Gets the properties of the specified machine learning workspace.",
        "operationId": "Workspaces_Get",
        "x-ms-examples": {
          "Get Workspace": {
            "$ref": "./examples/getWorkspace.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The request was successful; the request was well-formed and received properly.",
            "schema": {
              "$ref": "#/definitions/Workspace"
            }
          },
          "default": {
            "description": "Error response describing why the operation failed",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      },
      "put": {
        "tags": [
          "Workspaces"
        ],
        "description": "Creates or updates a workspace with the specified parameters.",
        "operationId": "Workspaces_CreateOrUpdate",
        "x-ms-long-running-operation": true,
        "x-ms-examples": {
          "Create Workspace": {
            "$ref": "./examples/createWorkspace.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "name": "parameters",
            "in": "body",
            "description": "The parameters for creating or updating a machine learning workspace.",
            "required": true,
            "schema": {
              "$ref": "#/definitions/Workspace"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request was successful; the request was well-formed and received properly.",
            "schema": {
              "$ref": "#/definitions/Workspace"
            }
          },
          "201": {
            "description": "The request was successful; the request was well-formed and received properly.",
            "schema": {
              "$ref": "#/definitions/Workspace"
            }
          },
          "202": {
            "description": "The request was successful; the request was well-formed and received properly."
          },
          "default": {
            "description": "Error response describing why the operation failed",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      },
      "delete": {
        "tags": [
          "Workspaces"
        ],
        "description": "Deletes a machine learning workspace.",
        "operationId": "Workspaces_Delete",
        "x-ms-examples": {
          "Delete Workspace": {
            "$ref": "./examples/deleteWorkspace.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The request was successful; the request was well-formed and received properly."
          },
          "204": {
            "description": "The machine learning workspace does not exist in the subscription."
          },
          "default": {
            "description": "Error response describing why the operation failed",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      },
      "patch": {
        "tags": [
          "Workspaces"
        ],
        "description": "Updates a machine learning workspace with the specified parameters.",
        "operationId": "Workspaces_Update",
        "x-ms-examples": {
          "Update Workspace": {
            "$ref": "./examples/updateWorkspace.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "name": "parameters",
            "in": "body",
            "description": "The parameters for updating a machine learning workspace.",
            "required": true,
            "schema": {
              "$ref": "#/definitions/WorkspaceUpdateParameters"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request was successful; the request was well-formed and received properly.",
            "schema": {
              "$ref": "#/definitions/Workspace"
            }
          },
          "default": {
            "description": "Error response describing why the operation failed",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/features": {
      "get": {
        "tags": [
          "Workspaces"
        ],
        "description": "Lists all enabled features for a workspace",
        "operationId": "WorkspaceFeatures_List",
        "x-ms-examples": {
          "List Workspace features": {
            "$ref": "./examples/ListWorkspaceFeatures.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The request was successful; the request was well-formed and received properly.",
            "schema": {
              "$ref": "#/definitions/ListAmlUserFeatureResult"
            }
          },
          "default": {
            "description": "Error response describing why the operation failed",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        },
        "x-ms-pageable": {
          "nextLinkName": "nextLink"
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces": {
      "get": {
        "tags": [
          "Workspaces"
        ],
        "description": "Lists all the available machine learning workspaces under the specified resource group.",
        "operationId": "Workspaces_ListByResourceGroup",
        "x-ms-examples": {
          "Get Workspaces by Resource Group": {
            "$ref": "./examples/getWorkspacesByResourceGroup.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/PaginationParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The request was successful; the request was well-formed and received properly.",
            "schema": {
              "$ref": "#/definitions/WorkspaceListResult"
            }
          },
          "default": {
            "description": "Error response describing why the operation failed",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        },
        "x-ms-pageable": {
          "nextLinkName": "nextLink"
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/listKeys": {
      "post": {
        "tags": [
          "Workspaces"
        ],
        "description": "Lists all the keys associated with this workspace. This includes keys for the storage account, app insights and password for container registry",
        "operationId": "Workspaces_ListKeys",
        "x-ms-examples": {
          "List Workspace Keys": {
            "$ref": "./examples/listWorkspaceKeys.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The request was successful; the request was well-formed and received properly.",
            "schema": {
              "$ref": "#/definitions/ListWorkspaceKeysResult"
            }
          },
          "default": {
            "description": "Error response describing why the operation failed",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/resyncKeys": {
      "post": {
        "tags": [
          "Workspaces"
        ],
        "description": "Resync all the keys associated with this workspace. This includes keys for the storage account, app insights and password for container registry",
        "operationId": "Workspaces_ResyncKeys",
        "x-ms-examples": {
          "Resync Workspace Keys": {
            "$ref": "./examples/resyncWorkspaceKeys.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The request was successful; the request was well-formed and received properly."
          },
          "default": {
            "description": "Error response describing why the operation failed",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/providers/Microsoft.MachineLearningServices/locations/{location}/usages": {
      "get": {
        "tags": [
          "Usage"
        ],
        "operationId": "Usages_List",
        "description": "Gets the current usage information as well as limits for AML resources for given subscription and location.",
        "parameters": [
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "name": "location",
            "in": "path",
            "required": true,
            "type": "string",
            "description": "The location for which resource usage is queried.",
            "pattern": "^[-\\w\\._]+$"
          }
        ],
        "responses": {
          "200": {
            "description": "OK",
            "schema": {
              "$ref": "#/definitions/ListUsagesResult"
            }
          }
        },
        "x-ms-pageable": {
          "nextLinkName": "nextLink"
        },
        "x-ms-examples": {
          "List Usages": {
            "$ref": "./examples/ListUsages.json"
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/providers/Microsoft.MachineLearningServices/locations/{location}/vmSizes": {
      "get": {
        "tags": [
          "VirtualMachineSizes"
        ],
        "operationId": "VirtualMachineSizes_List",
        "description": "Returns supported VM Sizes in a location",
        "parameters": [
          {
            "name": "location",
            "in": "path",
            "required": true,
            "type": "string",
            "description": "The location upon which virtual-machine-sizes is queried.",
            "pattern": "^[-\\w\\._]+$"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "OK",
            "schema": {
              "$ref": "#/definitions/VirtualMachineSizeListResult"
            }
          }
        },
        "x-ms-examples": {
          "List VM Sizes": {
            "$ref": "./examples/ListVMSizesResult.json"
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/providers/Microsoft.MachineLearningServices/locations/{location}/updateQuotas": {
      "post": {
        "tags": [
          "Quota"
        ],
        "operationId": "Quotas_Update",
        "description": "Update quota for each VM family in workspace.",
        "parameters": [
          {
            "name": "location",
            "in": "path",
            "required": true,
            "type": "string",
            "description": "The location for update quota is queried.",
            "pattern": "^[-\\w\\._]+$"
          },
          {
            "name": "parameters",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/QuotaUpdateParameters"
            },
            "description": "Quota update parameters."
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The operation was successful.",
            "schema": {
              "$ref": "#/definitions/UpdateWorkspaceQuotasResult"
            }
          },
          "default": {
            "description": "Error response describing why the operation failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        },
        "x-ms-examples": {
          "update quotas": {
            "$ref": "./examples/updateQuota.json"
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/providers/Microsoft.MachineLearningServices/locations/{location}/Quotas": {
      "get": {
        "tags": [
          "Quota"
        ],
        "operationId": "Quotas_List",
        "description": "Gets the currently assigned Workspace Quotas based on VMFamily.",
        "parameters": [
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "name": "location",
            "in": "path",
            "required": true,
            "type": "string",
            "description": "The location for which resource usage is queried.",
            "pattern": "^[-\\w\\._]+$"
          }
        ],
        "responses": {
          "200": {
            "description": "OK",
            "schema": {
              "$ref": "#/definitions/ListWorkspaceQuotas"
            }
          }
        },
        "x-ms-pageable": {
          "nextLinkName": "nextLink"
        },
        "x-ms-examples": {
          "List workspace quotas by VMFamily": {
            "$ref": "./examples/ListWorkspaceQuotasByVMFamily.json"
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/providers/Microsoft.MachineLearningServices/workspaces": {
      "get": {
        "tags": [
          "Workspaces"
        ],
        "description": "Lists all the available machine learning workspaces under the specified subscription.",
        "operationId": "Workspaces_ListBySubscription",
        "x-ms-examples": {
          "Get Workspaces by subscription": {
            "$ref": "./examples/getWorkspacesBySubscription.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/PaginationParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The request was successful; the request was well-formed and received properly.",
            "schema": {
              "$ref": "#/definitions/WorkspaceListResult"
            }
          },
          "default": {
            "description": "Error response describing why the operation failed",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        },
        "x-ms-pageable": {
          "nextLinkName": "nextLink"
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/computes": {
      "get": {
        "tags": [
          "OperationalizationClusters",
          "MachineLearningComputes"
        ],
        "x-ms-pageable": {
          "nextLinkName": "nextLink"
        },
        "operationId": "MachineLearningCompute_ListByWorkspace",
        "description": "Gets computes in specified workspace.",
        "x-ms-examples": {
          "Get Computes": {
            "$ref": "./examples/getComputes.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/PaginationParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The response includes a paginated array of Machine Learning computes and a URI to the next set of results, if any. For the more information the limits of the number of items in a resource group, see https://azure.microsoft.com/en-us/documentation/articles/azure-subscription-service-limits/.",
            "schema": {
              "$ref": "#/definitions/PaginatedComputeResourcesList"
            }
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/computes/{computeName}": {
      "get": {
        "tags": [
          "OperationalizationClusters",
          "MachineLearningComputes"
        ],
        "operationId": "MachineLearningCompute_Get",
        "description": "Gets compute definition by its name. Any secrets (storage keys, service credentials, etc) are not returned - use 'keys' nested resource to get them.",
        "x-ms-examples": {
          "Get a AKS Compute": {
            "$ref": "./examples/getAKSCompute.json"
          },
          "Get a AML Compute": {
            "$ref": "./examples/getAmlCompute.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/ComputeNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "Success.",
            "schema": {
              "$ref": "#/definitions/ComputeResource"
            }
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      },
      "put": {
        "tags": [
          "OperationalizationClusters",
          "MachineLearningComputes"
        ],
        "operationId": "MachineLearningCompute_CreateOrUpdate",
        "description": "Creates or updates compute. This call will overwrite a compute if it exists. This is a nonrecoverable operation. If your intent is to create a new compute, do a GET first to verify that it does not exist yet.",
        "x-ms-long-running-operation": true,
        "x-ms-examples": {
          "Create a AML Compute": {
            "$ref": "./examples/createBasicAmlCompute.json"
          },
          "Create AKS Compute": {
            "$ref": "./examples/createBasicAKSCompute.json"
          },
          "Create a DataFactory Compute": {
            "$ref": "./examples/createBasicDataFactoryCompute.json"
          },
          "Update a AML Compute": {
            "$ref": "./examples/updateAmlCompute.json"
          },
          "Update a AKS Compute": {
            "$ref": "./examples/updateAKSCompute.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/ComputeNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/ComputeDefinitionParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "Compute creation or update initiated.",
            "schema": {
              "$ref": "#/definitions/ComputeResource"
            }
          },
          "201": {
            "description": "Compute creation or update initiated.",
            "headers": {
              "Azure-AsyncOperation": {
                "description": "URI to poll for asynchronous operation status.",
                "type": "string"
              }
            },
            "schema": {
              "$ref": "#/definitions/ComputeResource"
            }
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      },
      "patch": {
        "tags": [
          "OperationalizationClusters",
          "MachineLearningComputes"
        ],
        "operationId": "MachineLearningCompute_Update",
        "description": "Updates properties of a compute. This call will overwrite a compute if it exists. This is a nonrecoverable operation.",
        "x-ms-long-running-operation": true,
        "x-ms-examples": {
          "Update a AmlCompute Compute": {
            "$ref": "./examples/patchAmlCompute.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/ComputeNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "name": "parameters",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/ClusterUpdateParameters"
            },
            "description": "Additional parameters for cluster update."
          }
        ],
        "responses": {
          "200": {
            "description": "Compute update initiated.",
            "schema": {
              "$ref": "#/definitions/ComputeResource"
            }
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      },
      "delete": {
        "tags": [
          "OperationalizationClusters",
          "MachineLearningComputes"
        ],
        "operationId": "MachineLearningCompute_Delete",
        "description": "Deletes specified Machine Learning compute.",
        "x-ms-long-running-operation": true,
        "x-ms-examples": {
          "Delete Compute": {
            "$ref": "./examples/deleteCompute.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/ComputeNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/UnderlyingResourceActionParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The request was successful; the request was well-formed and received properly."
          },
          "202": {
            "description": "Compute deletion initiated.",
            "headers": {
              "Azure-AsyncOperation": {
                "description": "URI to poll for asynchronous operation status.",
                "type": "string"
              },
              "Location": {
                "description": "URI to poll for asynchronous operation result.",
                "type": "string"
              }
            }
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/computes/{computeName}/listNodes": {
      "post": {
        "tags": [
          "MachineLearningComputes"
        ],
        "operationId": "MachineLearningCompute_ListNodes",
        "description": "Get the details (e.g IP address, port etc) of all the compute nodes in the compute.",
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/ComputeNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The operation was successful. The response contains the list of IP addresses.",
            "schema": {
              "$ref": "#/definitions/AmlComputeNodesInformation"
            }
          },
          "default": {
            "description": "Error response describing why the operation failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        },
        "x-ms-examples": {
          "Get compute nodes information for a compute": {
            "$ref": "./examples/amlComputeListNodes.json"
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/computes/{computeName}/listKeys": {
      "post": {
        "tags": [
          "OperationalizationClusters",
          "MachineLearningComputes"
        ],
        "operationId": "MachineLearningCompute_ListKeys",
        "description": "Gets secrets related to Machine Learning compute (storage keys, service credentials, etc).",
        "x-ms-examples": {
          "List AKS Compute Keys": {
            "$ref": "./examples/listKeysAKSCompute.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/ComputeNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "Success.",
            "schema": {
              "$ref": "#/definitions/ComputeSecrets"
            }
          },
          "default": {
            "description": "Error response describing why the operation failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/providers/Microsoft.MachineLearningServices/workspaces/skus": {
      "get": {
        "tags": [
          "WorkspaceSkus"
        ],
        "description": "Lists all skus with associated features",
        "operationId": "ListSkus",
        "x-ms-examples": {
          "List Skus": {
            "$ref": "./examples/ListSkus.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The request was successful; the request was well-formed and received properly.",
            "schema": {
              "$ref": "#/definitions/SkuListResult"
            }
          },
          "default": {
            "description": "Error response describing why the operation failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        },
        "x-ms-pageable": {
          "nextLinkName": "nextLink"
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/privateEndpointConnections/{privateEndpointConnectionName}": {
      "get": {
        "tags": [
          "WorkspacePrivateEndpointConnections"
        ],
        "operationId": "PrivateEndpointConnections_Get",
        "description": "Gets the specified private endpoint connection associated with the workspace.",
        "x-ms-examples": {
          "WorkspaceGetPrivateEndpointConnection": {
            "$ref": "./examples/workspaceGetPrivateEndpointConnection.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/PrivateEndpointConnectionName"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "OK -- Get the private endpoint connection properties successfully.",
            "schema": {
              "$ref": "#/definitions/PrivateEndpointConnection"
            }
          },
          "default": {
            "description": "Error response describing why the operation failed.",
            "schema": {
              "$ref": "#/definitions/ErrorResponse"
            }
          }
        }
      },
      "put": {
        "tags": [
          "WorkspacePrivateEndpointConnections"
        ],
        "operationId": "PrivateEndpointConnections_Put",
        "description": "Update the state of specified private endpoint connection associated with the workspace.",
        "x-ms-examples": {
          "WorkspacePutPrivateEndpointConnection": {
            "$ref": "./examples/workspacePutPrivateEndpointConnection.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/PrivateEndpointConnectionName"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "name": "properties",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/PrivateEndpointConnection"
            },
            "description": "The private endpoint connection properties."
          }
        ],
        "responses": {
          "200": {
            "description": "OK -- Update the private endpoint connection properties successfully.",
            "schema": {
              "$ref": "#/definitions/PrivateEndpointConnection"
            }
          },
          "default": {
            "description": "Error response describing why the operation failed.",
            "schema": {
              "$ref": "#/definitions/ErrorResponse"
            }
          }
        }
      },
      "delete": {
        "tags": [
          "WorkspacePrivateEndpointConnections"
        ],
        "operationId": "PrivateEndpointConnections_Delete",
        "description": "Deletes the specified private endpoint connection associated with the workspace.",
        "x-ms-examples": {
          "WorkspaceDeletePrivateEndpointConnection": {
            "$ref": "./examples/workspaceDeletePrivateEndpointConnection.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/PrivateEndpointConnectionName"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "OK -- Delete the private endpoint connection successfully."
          },
          "204": {
            "description": "No Content -- The private endpoint connection does not exist."
          },
          "default": {
            "description": "Error response describing why the operation failed.",
            "schema": {
              "$ref": "#/definitions/ErrorResponse"
            }
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/privateLinkResources": {
      "get": {
        "tags": [
          "WorkspacePrivateLinkResources"
        ],
        "operationId": "PrivateLinkResources_ListByWorkspace",
        "description": "Gets the private link resources that need to be created for a workspace.",
        "x-ms-examples": {
          "WorkspaceListPrivateLinkResources": {
            "$ref": "./examples/workspaceListPrivateLinkResources.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "Successfully retrieved private link resources.",
            "schema": {
              "$ref": "#/definitions/PrivateLinkResourceListResult"
            }
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/linkedWorkspaces": {
      "get": {
        "tags": [
          "LinkedWorkspaces"
        ],
        "x-ms-examples": {
          "ListLinkedWorkspaces": {
            "$ref": "./examples/listLinkedWorkspaces.json"
          }
        },
        "operationId": "LinkedWorkspaces_List",
        "description": "List all linked workspaces under a AML workspace.",
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "Successfully retrieved the linked workspaces.",
            "schema": {
              "type": "array",
              "description": "array of linked workspaces.",
              "items": {
                "$ref": "#/definitions/LinkedWorkspace"
              }
            }
          },
          "default": {
            "description": "Error response describing why the operation failed",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/linkedWorkspaces/{linkName}": {
      "put": {
        "tags": [
          "LinkedWorkspaces"
        ],
        "operationId": "LinkedWorkspaces_Create",
        "description": "Add a new linked workspace.",
        "x-ms-examples": {
          "CreateLinkedWorkspace": {
            "$ref": "./examples/createLinkedWorkspace.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/LinkName"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "name": "parameters",
            "in": "body",
            "description": "The object for creating or updating a new linked workspace",
            "required": true,
            "schema": {
              "$ref": "#/definitions/LinkedWorkspaceDto"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successfully created the linked workspace.",
            "schema": {
              "$ref": "#/definitions/LinkedWorkspace"
            }
          },
          "default": {
            "description": "Error response describing why the operation failed",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      },
      "get": {
        "tags": [
          "LinkedWorkspaces"
        ],
        "operationId": "LinkedWorkspaces_Get",
        "description": "Get the detail of a linked workspace.",
        "x-ms-examples": {
          "GetLinkedWorkspace": {
            "$ref": "./examples/getLinkedWorkspace.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/LinkName"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "Successfully retrieved the detail of the linked workspace.",
            "schema": {
              "$ref": "#/definitions/LinkedWorkspace"
            }
          },
          "default": {
            "description": "Error response describing why the operation failed",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      },
      "delete": {
        "tags": [
          "LinkedWorkspaces"
        ],
        "operationId": "LinkedWorkspaces_Delete",
        "description": "Delete a linked workspace.",
        "x-ms-examples": {
          "DeleteLinkedWorkspace": {
            "$ref": "./examples/deleteLinkedWorkspace.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/LinkName"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "Successfully deleted the linked workspace."
          },
          "204": {
            "description": "Specific linked workspace not found."
          },
          "default": {
            "description": "Error response describing why the operation failed",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/services": {
      "get": {
        "tags": [
          "MachineLearningServices"
        ],
        "x-ms-pageable": {
          "nextLinkName": "nextLink"
        },
        "operationId": "MachineLearningService_ListByWorkspace",
        "description": "Gets services in specified workspace.",
        "x-ms-examples": {
          "Get Services": {
            "$ref": "./examples/getServices.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/PaginationParameter"
          },
          {
            "$ref": "#/parameters/ModelIdParameter"
          },
          {
            "$ref": "#/parameters/ModelNameParameter"
          },
          {
            "$ref": "#/parameters/WebServiceTagParameter"
          },
          {
            "$ref": "#/parameters/WebServiceTagsParameter"
          },
          {
            "$ref": "#/parameters/WebServicePropertiesParameter"
          },
          {
            "$ref": "#/parameters/WebServiceRunIdParameter"
          },
          {
            "$ref": "#/parameters/WebServiceExpandParameter"
          },
          {
            "$ref": "#/parameters/WebServiceOrderByParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The response includes a paginated array of Machine Learning services and a URI to the next set of results, if any. For the more information the limits of the number of items in a resource group, see https://azure.microsoft.com/en-us/documentation/articles/azure-subscription-service-limits/.",
            "schema": {
              "$ref": "#/definitions/PaginatedServiceList"
            }
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/services/{serviceName}": {
      "get": {
        "tags": [
          "MachineLearningServices"
        ],
        "operationId": "MachineLearningService_Get",
        "description": "Get a Service by name.",
        "x-ms-examples": {
          "Get Service": {
            "$ref": "./examples/getService.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/WebServiceNameParameter"
          },
          {
            "in": "query",
            "name": "expand",
            "description": "Set to True to include Model details.",
            "type": "boolean",
            "default": false
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "schema": {
              "$ref": "#/definitions/ServiceResource"
            }
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      },
      "delete": {
        "tags": [
          "MachineLearningServices"
        ],
        "operationId": "MachineLearningService_Delete",
        "description": "Delete a specific Service..",
        "x-ms-examples": {
          "Delete Service": {
            "$ref": "./examples/deleteService.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/WebServiceNameParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The resource exists and was deleted successfully."
          },
          "204": {
            "description": "The resource does not exist and the request was well formed."
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      },
      "put": {
        "tags": [
          "MachineLearningServices"
        ],
        "description": "Creates or updates service. This call will update a service if it exists. This is a nonrecoverable operation. If your intent is to create a new service, do a GET first to verify that it does not exist yet.",
        "operationId": "MachineLearningService_CreateOrUpdate",
        "x-ms-long-running-operation": true,
        "x-ms-examples": {
          "Create Or Update service": {
            "$ref": "./examples/createOrUpdateService.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/WebServiceNameParameter"
          },
          {
            "in": "body",
            "name": "properties",
            "description": "The payload that is used to create or update the Service.",
            "required": true,
            "schema": {
              "$ref": "#/definitions/CreateServiceRequest"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Service creation or update initiated.",
            "schema": {
              "$ref": "#/definitions/ServiceResource"
            }
          },
          "201": {
            "description": "Service creation or update initiated.",
            "headers": {
              "Azure-AsyncOperation": {
                "description": "URI to poll for asynchronous operation status.",
                "type": "string"
              }
            }
          },
          "default": {
            "description": "Error response describing why the operation failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/datasets": {
      "get": {
        "tags": [
          "MachineLearningDatasets"
        ],
        "x-ms-pageable": {
          "nextLinkName": "nextLink"
        },
        "operationId": "MachineLearningDatasets_ListByWorkspace",
        "description": "Gets datasets in specified workspace.",
        "x-ms-examples": {
          "Get Datasets": {
            "$ref": "./examples/getDatasets.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/PaginationParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The response includes a paginated array of Machine Learning datasets and a URI to the next set of results, if any. For the more information the limits of the number of items in a resource group, see https://azure.microsoft.com/en-us/documentation/articles/azure-subscription-service-limits/.",
            "schema": {
              "$ref": "#/definitions/PaginatedDatasetResourcesList"
            }
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/datasets/{datasetName}": {
      "get": {
        "tags": [
          "MachineLearningDatasets"
        ],
        "operationId": "MachineLearningDatasets_Get",
        "description": "Get a Dataset by name.",
        "x-ms-examples": {
          "Get Dataset": {
            "$ref": "./examples/getDataset.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/DatasetNameParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "schema": {
              "$ref": "#/definitions/DatasetResource"
            }
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      },
      "put": {
        "tags": [
          "MachineLearningDatasets"
        ],
        "operationId": "MachineLearningDatasets_CreateOrUpdate",
        "description": "Creates or updates dataset. This call will overwrite a dataset if it exists. This is a nonrecoverable operation. If your intent is to create a new dataset, do a GET first to verify that it does not exist yet.",
        "x-ms-long-running-operation": true,
        "x-ms-examples": {
          "Create Dataset": {
            "$ref": "./examples/createOrUpdateDataset.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/DatasetNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "in": "body",
            "name": "properties",
            "description": "The payload that is used to create or update the Dataset.",
            "required": true,
            "schema": {
              "$ref": "#/definitions/DatasetCreateRequest"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Dataset creation or update initiated.",
            "schema": {
              "$ref": "#/definitions/DatasetResource"
            }
          },
          "201": {
            "description": "Dataset creation or update initiated.",
            "headers": {
              "Azure-AsyncOperation": {
                "description": "URI to poll for asynchronous operation status.",
                "type": "string"
              }
            }
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      },
      "delete": {
        "tags": [
          "MachineLearningDatasets"
        ],
        "operationId": "MachineLearningDatasets_Delete",
        "description": "Deletes specified Machine Learning Dataset.",
        "x-ms-examples": {
          "Delete Dataset": {
            "$ref": "./examples/deleteDataset.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/DatasetNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The request was successful; the request was well-formed and received properly."
          },
          "204": {
            "description": "The resource does not exist and the request was well formed."
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/datastores": {
      "get": {
        "tags": [
          "MachineLearningDatastores"
        ],
        "x-ms-pageable": {
          "nextLinkName": "nextLink"
        },
        "operationId": "MachineLearningDatastores_ListByWorkspace",
        "description": "Gets datastores in specified workspace.",
        "x-ms-examples": {
          "Get Datastores": {
            "$ref": "./examples/getDatastores.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/PaginationParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The response includes a paginated array of Machine Learning datastores and a URI to the next set of results, if any. For the more information the limits of the number of items in a resource group, see https://azure.microsoft.com/en-us/documentation/articles/azure-subscription-service-limits/.",
            "schema": {
              "$ref": "#/definitions/PaginatedDatastoreResourcesList"
            }
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      }
    },
    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/datastores/{datastoreName}": {
      "get": {
        "tags": [
          "MachineLearningDatastores"
        ],
        "operationId": "MachineLearningDatastores_Get",
        "description": "Get a Datastore by name.",
        "x-ms-examples": {
          "Get Datastore": {
            "$ref": "./examples/getDatastore.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "$ref": "#/parameters/DatastoreNameParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "schema": {
              "$ref": "#/definitions/DatastoreResource"
            }
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      },
      "put": {
        "tags": [
          "MachineLearningDatastores"
        ],
        "operationId": "MachineLearningDatastores_CreateOrUpdate",
        "description": "Creates or updates datastore. This call will overwrite a dataset if it exists. This is a nonrecoverable operation. If your intent is to create a new dataset, do a GET first to verify that it does not exist yet.",
        "x-ms-long-running-operation": true,
        "x-ms-examples": {
          "Create Blob Datastore": {
            "$ref": "./examples/createOrUpdateBlobDatastore.json"
          },
          "Create File Datastore": {
            "$ref": "./examples/createOrUpdateFileDatastore.json"
          },
          "Create SQL Datastore": {
            "$ref": "./examples/createOrUpdateSqlDatastore.json"
          },
          "Create PostgreSQL Datastore": {
            "$ref": "./examples/createOrUpdatePostgreSqlDatastore.json"
          },
          "Create MySQL Datastore": {
            "$ref": "./examples/createOrUpdateMySqlDatastore.json"
          },
          "Create ADLS  Datastore": {
            "$ref": "./examples/createOrUpdateAdlsDatastore.json"
          },
          "Create ADLS Gen2 Datastore": {
            "$ref": "./examples/createOrUpdateAdlsGen2Datastore.json"
          },
          "Create Databricks File System Datastore": {
            "$ref": "./examples/createOrUpdateDbfsDatastore.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/DatastoreNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          },
          {
            "in": "body",
            "name": "properties",
            "description": "The payload that is used to create or update the Datastore.",
            "required": true,
            "schema": {
              "$ref": "#/definitions/DatastoreCreateRequest"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Datastore creation or update initiated.",
            "schema": {
              "$ref": "#/definitions/DatastoreResource"
            }
          },
          "201": {
            "description": "Datastore creation or update initiated.",
            "headers": {
              "Azure-AsyncOperation": {
                "description": "URI to poll for asynchronous operation status.",
                "type": "string"
              }
            }
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      },
      "delete": {
        "tags": [
          "MachineLearningDatastores"
        ],
        "operationId": "MachineLearningDatastores_Delete",
        "description": "Deletes specified Machine Learning Datastore.",
        "x-ms-examples": {
          "Delete Datastore": {
            "$ref": "./examples/deleteDatastore.json"
          }
        },
        "parameters": [
          {
            "$ref": "#/parameters/SubscriptionIdParameter"
          },
          {
            "$ref": "#/parameters/ResourceGroupNameParameter"
          },
          {
            "$ref": "#/parameters/WorkspaceNameParameter"
          },
          {
            "$ref": "#/parameters/DatastoreNameParameter"
          },
          {
            "$ref": "#/parameters/APIVersionParameter"
          }
        ],
        "responses": {
          "200": {
            "description": "The request was successful; the request was well-formed and received properly."
          },
          "204": {
            "description": "The resource does not exist and the request was well formed."
          },
          "default": {
            "description": "Error response describing why the request failed.",
            "schema": {
              "$ref": "#/definitions/MachineLearningServiceError"
            }
          }
        }
      }
    }
  },
  "parameters": {
    "SubscriptionIdParameter": {
      "name": "subscriptionId",
      "description": "Azure subscription identifier.",
      "in": "path",
      "type": "string",
      "required": true
    },
    "ResourceGroupNameParameter": {
      "name": "resourceGroupName",
      "description": "Name of the resource group in which workspace is located.",
      "in": "path",
      "type": "string",
      "required": true,
      "x-ms-parameter-location": "method"
    },
    "WorkspaceNameParameter": {
      "name": "workspaceName",
      "description": "Name of Azure Machine Learning workspace.",
      "in": "path",
      "type": "string",
      "required": true,
      "x-ms-parameter-location": "method"
    },
    "ComputeNameParameter": {
      "name": "computeName",
      "description": "Name of the Azure Machine Learning compute.",
      "in": "path",
      "type": "string",
      "required": true,
      "x-ms-parameter-location": "method"
    },
    "AsyncOperationIdParameter": {
      "name": "asyncOperationId",
      "description": "Identifier of an asynchronous Azure Machine Learning compute operation.",
      "in": "path",
      "type": "string",
      "required": true,
      "x-ms-parameter-location": "method"
    },
    "LocationParameter": {
      "name": "location",
      "description": "The name of the Azure location/region.",
      "in": "path",
      "type": "string",
      "required": true,
      "x-ms-parameter-location": "method"
    },
    "APIVersionParameter": {
      "in": "query",
      "name": "api-version",
      "type": "string",
      "description": "Version of Azure Machine Learning resource provider API.",
      "required": true
    },
    "PaginationParameter": {
      "in": "query",
      "name": "$skiptoken",
      "type": "string",
      "description": "Continuation token for pagination.",
      "required": false,
      "x-ms-parameter-location": "method"
    },
    "ComputeDefinitionParameter": {
      "in": "body",
      "name": "parameters",
      "description": "Payload with Machine Learning compute definition.",
      "required": true,
      "schema": {
        "$ref": "#/definitions/ComputeResource"
      },
      "x-ms-parameter-location": "method"
    },
    "ComputeTypeParameter": {
      "in": "query",
      "name": "compute-type",
      "type": "string",
      "description": "Type of compute to filter by.",
      "required": false,
      "x-ms-parameter-location": "method"
    },
    "UnderlyingResourceActionParameter": {
      "in": "query",
      "name": "underlyingResourceAction",
      "type": "string",
      "description": "Delete the underlying compute if 'Delete', or detach the underlying compute from workspace if 'Detach'.",
      "required": true,
      "enum": [
        "Delete",
        "Detach"
      ],
      "x-ms-enum": {
        "name": "UnderlyingResourceAction",
        "modelAsString": true
      },
      "x-ms-parameter-location": "method"
    },
    "PrivateEndpointConnectionName": {
      "name": "privateEndpointConnectionName",
      "in": "path",
      "required": true,
      "type": "string",
      "description": "The name of the private endpoint connection associated with the workspace",
      "x-ms-parameter-location": "method"
    },
    "LinkName": {
      "name": "linkName",
      "in": "path",
      "required": true,
      "type": "string",
      "description": "Friendly name of the linked workspace",
      "x-ms-parameter-location": "method"
    },
    "ModelIdParameter": {
      "in": "query",
      "name": "modelId",
      "type": "string",
      "description": "The Model Id.",
      "required": false,
      "x-ms-parameter-location": "method"
    },
    "ModelNameParameter": {
      "in": "query",
      "name": "modelName",
      "type": "string",
      "description": "The Model name.",
      "required": false,
      "x-ms-parameter-location": "method"
    },
    "WebServiceNameParameter": {
      "name": "serviceName",
      "description": "Name of the Azure Machine Learning service.",
      "in": "path",
      "type": "string",
      "required": true,
      "x-ms-parameter-location": "method"
    },
    "WebServiceTagParameter": {
      "in": "query",
      "name": "tag",
      "type": "string",
      "description": "The object tag.",
      "required": false,
      "x-ms-parameter-location": "method"
    },
    "WebServiceCountParameter": {
      "in": "query",
      "name": "count",
      "type": "integer",
      "format": "int32",
      "description": "The number of items to retrieve in a page.",
      "required": false,
      "x-ms-parameter-location": "method"
    },
    "WebServiceTagsParameter": {
      "in": "query",
      "name": "tags",
      "type": "string",
      "description": "A set of tags with which to filter the returned services. It is a comma separated string of tags key or tags key=value Example: tagKey1,tagKey2,tagKey3=value3 .",
      "required": false,
      "x-ms-parameter-location": "method"
    },
    "WebServicePropertiesParameter": {
      "in": "query",
      "name": "properties",
      "type": "string",
      "description": "A set of properties with which to filter the returned services. It is a comma separated string of properties key and/or properties key=value Example: propKey1,propKey2,propKey3=value3 .",
      "required": false,
      "x-ms-parameter-location": "method"
    },
    "WebServiceRunIdParameter": {
      "in": "query",
      "name": "runId",
      "type": "string",
      "description": "runId for model associated with service.",
      "required": false,
      "x-ms-parameter-location": "method"
    },
    "WebServiceExpandParameter": {
      "in": "query",
      "name": "expand",
      "type": "boolean",
      "description": "Set to True to include Model details.",
      "required": false,
      "x-ms-parameter-location": "method"
    },
    "WebServiceOrderByParameter": {
      "in": "query",
      "name": "orderby",
      "type": "string",
      "description": "The option to order the response.",
      "required": false,
      "default": "UpdatedAtDesc",
      "enum": [
        "CreatedAtDesc",
        "CreatedAtAsc",
        "UpdatedAtDesc",
        "UpdatedAtAsc"
      ],
      "x-ms-enum": {
        "name": "OrderString",
        "modelAsString": true
      },
      "x-ms-parameter-location": "method"
    },
    "DatasetNameParameter": {
      "in": "path",
      "name": "datasetName",
      "type": "string",
      "description": "The Dataset name.",
      "required": true,
      "x-ms-parameter-location": "method"
    },
    "DatastoreNameParameter": {
      "in": "path",
      "name": "datastoreName",
      "type": "string",
      "description": "The Datastore name.",
      "required": true,
      "x-ms-parameter-location": "method"
    }
  },
  "definitions": {
    "Operation": {
      "description": "Azure Machine Learning workspace REST API operation",
      "type": "object",
      "properties": {
        "name": {
          "description": "Operation name: {provider}/{resource}/{operation}",
          "type": "string"
        },
        "display": {
          "description": "Display name of operation",
          "properties": {
            "provider": {
              "description": "The resource provider name: Microsoft.MachineLearningExperimentation",
              "type": "string"
            },
            "resource": {
              "description": "The resource on which the operation is performed.",
              "type": "string"
            },
            "operation": {
              "description": "The operation that users can perform.",
              "type": "string"
            },
            "description": {
              "description": "The description for the operation.",
              "type": "string"
            }
          }
        }
      }
    },
    "OperationListResult": {
      "description": "An array of operations supported by the resource provider.",
      "properties": {
        "value": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/Operation"
          },
          "description": "List of AML workspace operations supported by the AML workspace resource provider."
        }
      }
    },
    "Workspace": {
      "type": "object",
      "description": "An object that represents a machine learning workspace.",
      "allOf": [
        {
          "$ref": "#/definitions/Resource"
        }
      ],
      "properties": {
        "properties": {
          "$ref": "#/definitions/WorkspaceProperties",
          "description": "The properties of the machine learning workspace.",
          "x-ms-client-flatten": true
        }
      }
    },
    "WorkspaceProperties": {
      "type": "object",
      "description": "The properties of a machine learning workspace.",
      "properties": {
        "workspaceId": {
          "description": "The immutable id associated with this workspace.",
          "type": "string",
          "readOnly": true
        },
        "description": {
          "description": "The description of this workspace.",
          "type": "string"
        },
        "friendlyName": {
          "description": "The friendly name for this workspace. This name in mutable",
          "type": "string"
        },
        "creationTime": {
          "format": "date-time",
          "description": "The creation time of the machine learning workspace in ISO8601 format.",
          "type": "string",
          "readOnly": true
        },
        "keyVault": {
          "description": "ARM id of the key vault associated with this workspace. This cannot be changed once the workspace has been created",
          "type": "string"
        },
        "applicationInsights": {
          "description": "ARM id of the application insights associated with this workspace. This cannot be changed once the workspace has been created",
          "type": "string"
        },
        "containerRegistry": {
          "description": "ARM id of the container registry associated with this workspace. This cannot be changed once the workspace has been created",
          "type": "string"
        },
        "storageAccount": {
          "description": "ARM id of the storage account associated with this workspace. This cannot be changed once the workspace has been created",
          "type": "string"
        },
        "discoveryUrl": {
          "description": "Url for the discovery service to identify regional endpoints for machine learning experimentation services",
          "type": "string"
        },
        "provisioningState": {
          "type": "string",
          "enum": [
            "Unknown",
            "Updating",
            "Creating",
            "Deleting",
            "Succeeded",
            "Failed",
            "Canceled"
          ],
          "x-ms-enum": {
            "name": "ProvisioningState",
            "modelAsString": true
          },
          "readOnly": true,
          "description": "The current deployment state of workspace resource. The provisioningState is to indicate states for resource provisioning."
        },
        "encryption": {
          "$ref": "#/definitions/EncryptionProperty",
          "description": "The encryption settings of Azure ML workspace."
        },
        "hbiWorkspace": {
          "type": "boolean",
          "description": "The flag to signal HBI data in the workspace and reduce diagnostic data collected by the service",
          "default": false
        },
        "serviceProvisionedResourceGroup": {
          "type": "string",
          "description": "The name of the managed resource group created by workspace RP in customer subscription if the workspace is CMK workspace",
          "readOnly": true
        },
        "privateLinkCount": {
          "type": "integer",
          "format": "int32",
          "description": "Count of private connections in the workspace",
          "readOnly": true
        },
        "imageBuildCompute": {
          "description": "The compute name for image build",
          "type": "string"
        },
        "allowPublicAccessWhenBehindVnet": {
          "type": "boolean",
          "description": "The flag to indicate whether to allow public access when behind VNet.",
          "default": false
        },
        "privateEndpointConnections": {
          "readOnly": true,
          "type": "array",
          "items": {
            "$ref": "#/definitions/PrivateEndpointConnection"
          },
          "description": "The list of private endpoint connections in the workspace."
        },
        "sharedPrivateLinkResources": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/SharedPrivateLinkResource"
          },
          "description": "The list of shared private link resources in this workspace."
        }
      }
    },
    "WorkspaceUpdateParameters": {
      "description": "The parameters for updating a machine learning workspace.",
      "properties": {
        "tags": {
          "description": "The resource tags for the machine learning workspace.",
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        },
        "sku": {
          "$ref": "#/definitions/Sku",
          "description": "The sku of the workspace."
        },
        "properties": {
          "$ref": "#/definitions/WorkspacePropertiesUpdateParameters",
          "description": "The properties that the machine learning workspace will be updated with.",
          "x-ms-client-flatten": true
        }
      }
    },
    "WorkspacePropertiesUpdateParameters": {
      "description": "The parameters for updating the properties of a machine learning workspace.",
      "properties": {
        "description": {
          "description": "The description of this workspace.",
          "type": "string"
        },
        "friendlyName": {
          "description": "The friendly name for this workspace.",
          "type": "string"
        }
      }
    },
    "AmlUserFeature": {
      "description": "Features enabled for a workspace",
      "type": "object",
      "properties": {
        "id": {
          "description": "Specifies the feature ID",
          "type": "string"
        },
        "displayName": {
          "description": "Specifies the feature name ",
          "type": "string"
        },
        "description": {
          "description": "Describes the feature for user experience",
          "type": "string"
        }
      }
    },
    "ListAmlUserFeatureResult": {
      "properties": {
        "value": {
          "readOnly": true,
          "type": "array",
          "items": {
            "$ref": "#/definitions/AmlUserFeature"
          },
          "description": "The list of AML user facing features."
        },
        "nextLink": {
          "readOnly": true,
          "type": "string",
          "description": "The URI to fetch the next page of AML user features information. Call ListNext() with this to fetch the next page of AML user features information."
        }
      },
      "description": "The List Aml user feature operation response."
    },
    "UsageName": {
      "properties": {
        "value": {
          "readOnly": true,
          "type": "string",
          "description": "The name of the resource."
        },
        "localizedValue": {
          "readOnly": true,
          "type": "string",
          "description": "The localized name of the resource."
        }
      },
      "description": "The Usage Names."
    },
    "Usage": {
      "type": "object",
      "properties": {
        "id": {
          "readOnly": true,
          "type": "string",
          "description": "Specifies the resource ID."
        },
        "type": {
          "readOnly": true,
          "type": "string",
          "description": "Specifies the resource type."
        },
        "unit": {
          "readOnly": true,
          "type": "string",
          "description": "An enum describing the unit of usage measurement.",
          "enum": [
            "Count"
          ],
          "x-ms-enum": {
            "name": "UsageUnit",
            "modelAsString": true
          }
        },
        "currentValue": {
          "readOnly": true,
          "type": "integer",
          "format": "int64",
          "description": "The current usage of the resource."
        },
        "limit": {
          "readOnly": true,
          "type": "integer",
          "format": "int64",
          "description": "The maximum permitted usage of the resource."
        },
        "name": {
          "readOnly": true,
          "$ref": "#/definitions/UsageName",
          "description": "The name of the type of usage."
        }
      },
      "description": "Describes AML Resource Usage."
    },
    "ListUsagesResult": {
      "properties": {
        "value": {
          "readOnly": true,
          "type": "array",
          "items": {
            "$ref": "#/definitions/Usage"
          },
          "description": "The list of AML resource usages."
        },
        "nextLink": {
          "readOnly": true,
          "type": "string",
          "description": "The URI to fetch the next page of AML resource usage information. Call ListNext() with this to fetch the next page of AML resource usage information."
        }
      },
      "description": "The List Usages operation response."
    },
    "VirtualMachineSize": {
      "properties": {
        "name": {
          "type": "string",
          "title": "Virtual Machine size name",
          "description": "The name of the virtual machine size.",
          "readOnly": true
        },
        "family": {
          "type": "string",
          "title": "Virtual Machine family name",
          "description": "The family name of the virtual machine size.",
          "readOnly": true
        },
        "vCPUs": {
          "type": "integer",
          "format": "int32",
          "title": "Number of vPUs",
          "description": "The number of vCPUs supported by the virtual machine size.",
          "readOnly": true
        },
        "gpus": {
          "type": "integer",
          "format": "int32",
          "title": "Number of gPUs",
          "description": "The number of gPUs supported by the virtual machine size.",
          "readOnly": true
        },
        "osVhdSizeMB": {
          "type": "integer",
          "format": "int32",
          "title": "OS VHD Disk size",
          "description": "The OS VHD disk size, in MB, allowed by the virtual machine size.",
          "readOnly": true
        },
        "maxResourceVolumeMB": {
          "type": "integer",
          "format": "int32",
          "title": "Resource volume size",
          "description": "The resource volume size, in MB, allowed by the virtual machine size.",
          "readOnly": true
        },
        "memoryGB": {
          "type": "number",
          "format": "double",
          "title": "Memory size",
          "description": "The amount of memory, in GB, supported by the virtual machine size.",
          "readOnly": true
        },
        "lowPriorityCapable": {
          "type": "boolean",
          "title": "Low priority capable",
          "description": "Specifies if the virtual machine size supports low priority VMs.",
          "readOnly": true
        },
        "premiumIO": {
          "type": "boolean",
          "title": "Premium IO supported",
          "description": "Specifies if the virtual machine size supports premium IO.",
          "readOnly": true
        }
      },
      "description": "Describes the properties of a VM size."
    },
    "VirtualMachineSizeListResult": {
      "properties": {
        "amlCompute": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/VirtualMachineSize"
          },
          "description": "The list of virtual machine sizes supported by AmlCompute."
        }
      },
      "description": "The List Virtual Machine size operation response."
    },
    "WorkspaceListResult": {
      "description": "The result of a request to list machine learning workspaces.",
      "properties": {
        "value": {
          "description": "The list of machine learning workspaces. Since this list may be incomplete, the nextLink field should be used to request the next list of machine learning workspaces.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/Workspace"
          }
        },
        "nextLink": {
          "description": "The URI that can be used to request the next list of machine learning workspaces.",
          "type": "string"
        }
      }
    },
    "QuotaBaseProperties": {
      "properties": {
        "id": {
          "type": "string",
          "description": "Specifies the resource ID."
        },
        "type": {
          "type": "string",
          "description": "Specifies the resource type."
        },
        "limit": {
          "type": "integer",
          "format": "int64",
          "title": "Limit.",
          "description": "The maximum permitted quota of the resource."
        },
        "unit": {
          "type": "string",
          "description": "An enum describing the unit of quota measurement.",
          "enum": [
            "Count"
          ],
          "x-ms-enum": {
            "name": "QuotaUnit",
            "modelAsString": true
          }
        }
      },
      "description": "The properties for Quota update or retrieval."
    },
    "QuotaUpdateParameters": {
      "properties": {
        "value": {
          "description": "The list for update quota.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/QuotaBaseProperties"
          }
        }
      },
      "description": "Quota update parameters."
    },
    "UpdateWorkspaceQuotasResult": {
      "properties": {
        "value": {
          "description": "The list of workspace quota update result.",
          "items": {
            "$ref": "#/definitions/UpdateWorkspaceQuotas"
          },
          "readOnly": true,
          "type": "array"
        },
        "nextLink": {
          "description": "The URI to fetch the next page of workspace quota update result. Call ListNext() with this to fetch the next page of Workspace Quota update result.",
          "readOnly": true,
          "type": "string"
        }
      },
      "description": "The result of update workspace quota."
    },
    "UpdateWorkspaceQuotas": {
      "properties": {
        "id": {
          "readOnly": true,
          "type": "string",
          "description": "Specifies the resource ID."
        },
        "type": {
          "readOnly": true,
          "type": "string",
          "description": "Specifies the resource type."
        },
        "limit": {
          "type": "integer",
          "format": "int64",
          "title": "Limit.",
          "description": "The maximum permitted quota of the resource."
        },
        "unit": {
          "readOnly": true,
          "type": "string",
          "description": "An enum describing the unit of quota measurement.",
          "enum": [
            "Count"
          ],
          "x-ms-enum": {
            "name": "QuotaUnit",
            "modelAsString": true
          }
        },
        "status": {
          "type": "string",
          "readOnly": false,
          "title": "Update Workspace Quota Status.",
          "description": "Status of update workspace quota.",
          "enum": [
            "Undefined",
            "Success",
            "Failure",
            "InvalidQuotaBelowClusterMinimum",
            "InvalidQuotaExceedsSubscriptionLimit",
            "InvalidVMFamilyName",
            "OperationNotSupportedForSku",
            "OperationNotEnabledForRegion"
          ],
          "x-ms-enum": {
            "name": "status",
            "modelAsString": true
          }
        }
      },
      "description": "The properties for update Quota response."
    },
    "ResourceName": {
      "properties": {
        "value": {
          "readOnly": true,
          "type": "string",
          "description": "The name of the resource."
        },
        "localizedValue": {
          "readOnly": true,
          "type": "string",
          "description": "The localized name of the resource."
        }
      },
      "description": "The Resource Name."
    },
    "ResourceQuota": {
      "properties": {
        "id": {
          "readOnly": true,
          "type": "string",
          "description": "Specifies the resource ID."
        },
        "type": {
          "readOnly": true,
          "type": "string",
          "description": "Specifies the resource type."
        },
        "name": {
          "$ref": "#/definitions/ResourceName",
          "description": "Name of the resource.",
          "readOnly": true
        },
        "limit": {
          "readOnly": true,
          "type": "integer",
          "format": "int64",
          "title": "Limit.",
          "description": "The maximum permitted quota of the resource."
        },
        "unit": {
          "readOnly": true,
          "type": "string",
          "description": "An enum describing the unit of quota measurement.",
          "enum": [
            "Count"
          ],
          "x-ms-enum": {
            "name": "QuotaUnit",
            "modelAsString": true
          }
        }
      },
      "description": "The quota assigned to a resource."
    },
    "ListWorkspaceQuotas": {
      "properties": {
        "value": {
          "description": "The list of Workspace Quotas by VM Family",
          "items": {
            "$ref": "#/definitions/ResourceQuota"
          },
          "readOnly": true,
          "type": "array"
        },
        "nextLink": {
          "description": "The URI to fetch the next page of workspace quota information by VM Family. Call ListNext() with this to fetch the next page of Workspace Quota information.",
          "readOnly": true,
          "type": "string"
        }
      },
      "description": "The List WorkspaceQuotasByVMFamily operation response."
    },
    "Identity": {
      "properties": {
        "principalId": {
          "readOnly": true,
          "type": "string",
          "description": "The principal ID of resource identity."
        },
        "tenantId": {
          "readOnly": true,
          "type": "string",
          "description": "The tenant ID of resource."
        },
        "type": {
          "type": "string",
          "description": "The identity type.",
          "enum": [
            "SystemAssigned",
            "SystemAssigned,UserAssigned",
            "UserAssigned",
            "None"
          ],
          "x-ms-enum": {
            "name": "ResourceIdentityType",
            "modelAsString": false
          }
        },
        "userAssignedIdentities": {
          "$ref": "#/definitions/UserAssignedIdentities",
          "description": "The user assigned identities associated with the resource."
        }
      },
      "description": "Identity for the resource."
    },
    "UserAssignedIdentities": {
      "description": "dictionary containing all the user assigned identities, with resourceId of the UAI as key.",
      "type": "object",
      "additionalProperties": {
        "$ref": "#/definitions/UserAssignedIdentity"
      }
    },
    "UserAssignedIdentity": {
      "description": "User Assigned Identity",
      "properties": {
        "principalId": {
          "readOnly": true,
          "type": "string",
          "description": "The principal ID of the user assigned identity."
        },
        "tenantId": {
          "readOnly": true,
          "type": "string",
          "description": "The tenant ID of the user assigned identity."
        },
        "clientId": {
          "readOnly": true,
          "type": "string",
          "description": "The clientId(aka appId) of the user assigned identity."
        }
      }
    },
    "Resource": {
      "description": "Azure Resource Manager resource envelope.",
      "x-ms-azure-resource": true,
      "properties": {
        "id": {
          "description": "Specifies the resource ID.",
          "type": "string",
          "readOnly": true
        },
        "name": {
          "description": "Specifies the name of the resource.",
          "type": "string",
          "readOnly": true
        },
        "identity": {
          "$ref": "#/definitions/Identity",
          "description": "The identity of the resource."
        },
        "location": {
          "description": "Specifies the location of the resource.",
          "type": "string"
        },
        "type": {
          "description": "Specifies the type of the resource.",
          "type": "string",
          "readOnly": true
        },
        "tags": {
          "description": "Contains resource tags defined as key/value pairs.",
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        },
        "sku": {
          "$ref": "#/definitions/Sku",
          "description": "The sku of the workspace."
        }
      }
    },
    "ResourceId": {
      "properties": {
        "id": {
          "type": "string",
          "description": "The ID of the resource"
        }
      },
      "required": [
        "id"
      ],
      "description": "Represents a resource ID. For example, for a subnet, it is the resource URL for the subnet.",
      "x-ms-azure-resource": true
    },
    "ListWorkspaceKeysResult": {
      "type": "object",
      "properties": {
        "userStorageKey": {
          "readOnly": true,
          "type": "string"
        },
        "userStorageResourceId": {
          "readOnly": true,
          "type": "string"
        },
        "appInsightsInstrumentationKey": {
          "readOnly": true,
          "type": "string"
        },
        "containerRegistryCredentials": {
          "readOnly": true,
          "$ref": "#/definitions/RegistryListCredentialsResult"
        }
      }
    },
    "RegistryListCredentialsResult": {
      "type": "object",
      "properties": {
        "location": {
          "readOnly": true,
          "type": "string"
        },
        "username": {
          "readOnly": true,
          "type": "string"
        },
        "passwords": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/Password"
          }
        }
      }
    },
    "Password": {
      "type": "object",
      "properties": {
        "name": {
          "readOnly": true,
          "type": "string"
        },
        "value": {
          "readOnly": true,
          "type": "string"
        }
      }
    },
    "PaginatedDatasetResourcesList": {
      "type": "object",
      "description": "Paginated list of Machine Learning dataset objects wrapped in ARM resource envelope.",
      "properties": {
        "value": {
          "type": "array",
          "description": "An array of Machine Learning dataset objects wrapped in ARM resource envelope.",
          "items": {
            "$ref": "#/definitions/DatasetResource"
          }
        },
        "nextLink": {
          "type": "string",
          "description": "A continuation link (absolute URI) to the next page of results in the list."
        }
      }
    },
    "DatasetResource": {
      "type": "object",
      "description": "Machine Learning dataset object wrapped into ARM resource envelope.",
      "allOf": [
        {
          "$ref": "#/definitions/Resource"
        },
        {
          "type": "object",
          "properties": {
            "properties": {
              "description": "Dataset properties",
              "$ref": "#/definitions/Dataset"
            }
          }
        }
      ]
    },
    "Dataset": {
      "type": "object",
      "description": "Machine Learning dataset object.",
      "properties": {
        "datasetId": {
          "readOnly": true,
          "type": "string",
          "description": "Unique Dataset identifier."
        },
        "datasetState": {
          "type": "object",
          "$ref": "#/definitions/DatasetState"
        },
        "latest": {
          "type": "object",
          "description": "Last created Dataset definition.",
          "properties": {
            "datasetId": {
              "readOnly": true,
              "type": "string",
              "description": "Unique Dataset identifier."
            },
            "versionId": {
              "readOnly": true,
              "type": "string",
              "description": "An identifier uniquely identifies a definition change."
            },
            "datasetDefinitionState": {
              "type": "object",
              "$ref": "#/definitions/DatasetState"
            },
            "dataflow": {
              "readOnly": true,
              "type": "string",
              "description": "Dataflow Json"
            },
            "dataPath": {
              "type": "object",
              "description": " Datastore and reference to location of data such as relativePath, Sql Query and etc.",
              "properties": {
                "datastoreName": {
                  "readOnly": true,
                  "type": "string",
                  "description": "Data store Name"
                },
                "relativePath": {
                  "readOnly": true,
                  "type": "string",
                  "description": "Relative path in the data store"
                },
                "azureFilePath": {
                  "readOnly": true,
                  "type": "string",
                  "description": "Azure path for Azure Blob or File"
                },
                "paths": {
                  "type": "array",
                  "description": "List of files expanded from a file GLOB specified",
                  "items": {
                    "type": "string"
                  },
                  "readOnly": true
                },
                "sqlDataPath": {
                  "type": "object",
                  "description": "Sql Query/Table/Stored Procedure details.",
                  "properties": {
                    "sqlTableName": {
                      "readOnly": true,
                      "type": "string",
                      "description": "SQL table name"
                    },
                    "sqlQuery": {
                      "readOnly": true,
                      "type": "string",
                      "description": "SQL query"
                    },
                    "sqlStoredProcedureName": {
                      "readOnly": true,
                      "type": "string",
                      "description": "SQL storedProcedure name"
                    },
                    "queryTimeout": {
                      "readOnly": true,
                      "type": "integer",
                      "format": "int64",
                      "description": "SQL query timeout. Unit in seconds."
                    }
                  }
                },
                "httpUrl": {
                  "readOnly": true,
                  "type": "string",
                  "description": "HTTP URL."
                },
                "additionalProperties": {
                  "description": "Additional Properties.",
                  "type": "object",
                  "additionalProperties": {
                    "type": "object"
                  }
                },
                "partitionFormat": {
                  "readOnly": true,
                  "type": "string",
                  "description": "Specify the partition format of path. Defaults to None."
                },
                "partitionFormatIgnoreError": {
                  "type": "boolean",
                  "description": "Whether or not to ignore unmatched path.",
                  "readOnly": true
                }
              }
            },
            "partitionFormatInPath": {
              "type": "boolean",
              "description": "Indicates how the source data is partitioned. This is defined to filter on a range of partitioned data before performing actions or materialization.",
              "readOnly": true
            },
            "notes": {
              "type": "string",
              "description": "Summary of Definition changes.",
              "readOnly": true
            },
            "etag": {
              "type": "string",
              "description": "eTag description",
              "readOnly": true
            },
            "createdTime": {
              "format": "date-time",
              "description": "The dataset creation time (UTC).",
              "type": "string",
              "readOnly": true
            },
            "modifiedTime": {
              "format": "date-time",
              "description": "The dataset last modified time (UTC).",
              "type": "string",
              "readOnly": true
            },
            "createdBy": {
              "type": "object",
              "$ref": "#/definitions/UserInfo"
            },
            "fileType": {
              "readOnly": true,
              "type": "string",
              "description": "Dataset FileType, specified by user."
            },
            "properties": {
              "description": "Properties stores information like name of time series column for time series dataset.",
              "type": "object",
              "additionalProperties": {
                "type": "object"
              }
            },
            "savedDatasetId": {
              "readOnly": true,
              "type": "string",
              "description": "Indicates the saved dataset this definition is mapping to, populated on Get."
            },
            "telemetryInfo": {
              "description": " Telemetry information about the dataset including information like which service the dataset was created from.",
              "type": "object",
              "additionalProperties": {
                "type": "string"
              },
              "readOnly": true
            },
            "useDescriptionTagsFromDefinition": {
              "type": "boolean",
              "description": " Whether to use description and tags from the definition level as opposed to dataset level (old behavior).",
              "readOnly": true
            },
            "description": {
              "readOnly": true,
              "type": "string",
              "description": "Description about the dataset."
            },
            "tags": {
              "description": "Tags associated with the dataset.",
              "type": "object",
              "additionalProperties": {
                "type": "string"
              },
              "readOnly": true
            }
          }
        },
        "createdTime": {
          "format": "date-time",
          "description": "The dataset creation time (UTC).",
          "type": "string",
          "readOnly": true
        },
        "modifiedTime": {
          "format": "date-time",
          "description": "The dataset last modified time (UTC).",
          "type": "string",
          "readOnly": true
        },
        "etag": {
          "type": "string",
          "description": "eTag description",
          "readOnly": true
        },
        "name": {
          "type": "string",
          "description": "Unique dataset name",
          "readOnly": true
        },
        "description": {
          "type": "string",
          "description": "Description about this dataset version.",
          "readOnly": true
        },
        "tags": {
          "description": "Tags for this dataset version.",
          "type": "object",
          "additionalProperties": {
            "type": "string"
          },
          "readOnly": true
        },
        "isVisible": {
          "type": "boolean",
          "description": "Flag to hide Dataset in UI",
          "readOnly": true
        },
        "defaultCompute": {
          "type": "string",
          "description": "Name of the default compute to be used for any Dataset actions (such as Profile, Write).",
          "readOnly": true
        },
        "datasetType": {
          "type": "string",
          "description": "Dataset Type.",
          "readOnly": true
        }
      }
    },
    "DatasetState": {
      "type": "object",
      "description": "Dataset state",
      "properties": {
        "state": {
          "description": "Dataset state",
          "type": "string"
        },
        "deprecatedBy": {
          "description": "Reference to better Dataset or a Definition",
          "type": "object",
          "properties": {
            "datasetId": {
              "readOnly": true,
              "type": "string",
              "description": "Unique Dataset identifier."
            },
            "definitionVersion": {
              "description": "Definition Version",
              "type": "string"
            }
          }
        },
        "etag": {
          "type": "string",
          "description": "eTag description",
          "readOnly": true
        }
      }
    },
    "LinkedInfo": {
      "type": "object",
      "description": "Info about origin if it is linked.",
      "properties": {
        "linkedId": {
          "type": "string",
          "description": "LinkedId id."
        },
        "linkedResourceName": {
          "type": "string",
          "description": "Linked resource name."
        },
        "origin": {
          "$ref": "#/definitions/Origin"
        }
      }
    },
    "Origin": {
      "description": "Datastore origin",
      "enum": [
        "Synapse"
      ],
      "type": "string",
      "x-ms-enum": {
        "name": "Origin",
        "modelAsString": true
      }
    },
    "UserInfo": {
      "type": "object",
      "description": "User who created.",
      "properties": {
        "userObjectId": {
          "type": "string",
          "description": "A user or service principal's object ID.."
        },
        "userPuId": {
          "type": "string",
          "description": "A user or service principal's PuID."
        },
        "userIdp": {
          "type": "string",
          "description": "A user identity provider. Eg live.com"
        },
        "userAltSecId": {
          "type": "string",
          "description": "A user alternate sec id. This represents the user in a different identity provider system Eg.1:live.com:puid"
        },
        "userIss": {
          "type": "string",
          "description": "The issuer which issued the token for this user."
        },
        "userTenantId": {
          "type": "string",
          "description": "A user or service principal's tenant ID."
        },
        "userName": {
          "type": "string",
          "description": " A user's full name or a service principal's app ID."
        }
      }
    },
    "PaginatedDatastoreResourcesList": {
      "type": "object",
      "description": "Paginated list of Machine Learning datastore objects wrapped in ARM resource envelope.",
      "properties": {
        "value": {
          "type": "array",
          "description": "An array of Machine Learning datastore objects wrapped in ARM resource envelope.",
          "items": {
            "$ref": "#/definitions/DatastoreResource"
          }
        },
        "nextLink": {
          "type": "string",
          "description": "A continuation link (absolute URI) to the next page of results in the list."
        }
      }
    },
    "DatastoreResource": {
      "type": "object",
      "description": "Machine Learning datastore object wrapped into ARM resource envelope.",
      "allOf": [
        {
          "$ref": "#/definitions/Resource"
        },
        {
          "type": "object",
          "properties": {
            "properties": {
              "description": "Datastore properties",
              "$ref": "#/definitions/Datastore"
            }
          }
        }
      ]
    },
    "Datastore": {
      "type": "object",
      "description": "Machine Learning datastore object.",
      "properties": {
        "name": {
          "type": "string",
          "description": "Name of the datastore."
        },
        "description": {
          "type": "string",
          "description": "Description of the datastore."
        },
        "dataStoreType": {
          "description": "The datastore type.",
          "enum": [
            "AzureBlob",
            "AzureFile",
            "AzureDataLake",
            "AzureSqlDatabase",
            "AzurePostgreSql",
            "DBFS",
            "AzureDataLakeGen2",
            "AzureMySql"
          ],
          "type": "string",
          "x-ms-enum": {
            "name": "DataStoreType",
            "modelAsString": true
          }
        },
        "hasBeenValidated": {
          "type": "boolean",
          "default": false,
          "description": "A read only property that denotes whether the service datastore has been validated with credentials."
        },
        "tags": {
          "description": "Tags for this datastore.",
          "type": "object",
          "additionalProperties": {
            "type": "string"
          },
          "readOnly": true
        },
        "azureStorageSection": {
          "type": "object",
          "$ref": "#/definitions/AzureStorageSection"
        },
        "azureDataLakeSection": {
          "type": "object",
          "$ref": "#/definitions/AzureDataLakeSection"
        },
        "azureSqlDatabaseSection": {
          "type": "object",
          "$ref": "#/definitions/AzureSqlDatabaseSection"
        },
        "azurePostgreSqlSection": {
          "type": "object",
          "$ref": "#/definitions/AzurePostgreSqlSection"
        },
        "azureMySqlSection": {
          "type": "object",
          "$ref": "#/definitions/AzureMySqlSection"
        },
        "glusterFsSection": {
          "type": "object",
          "$ref": "#/definitions/GlusterFsSection"
        },
        "createdBy": {
          "type": "object",
          "description": "The User who created the datastore.",
          "$ref": "#/definitions/UserInfo",
          "readOnly": true
        },
        "modifiedBy": {
          "type": "object",
          "description": "The User who modified the datastore.",
          "$ref": "#/definitions/UserInfo",
          "readOnly": true
        },
        "createdTime": {
          "type": "string",
          "description": "The date and time when the datastore was created.",
          "format": "date-time",
          "readOnly": true
        },
        "modifiedTime": {
          "type": "string",
          "description": "The date and time when the datastore was last modified.",
          "format": "date-time",
          "readOnly": true
        },
        "linkedInfo": {
          "type": "object",
          "$ref": "#/definitions/LinkedInfo"
        }
      }
    },
    "AzureResourceDatastore": {
      "type": "object",
      "description": "Azure resource for datastore.",
      "properties": {
        "subscriptionId": {
          "type": "string",
          "description": "Subscription ID."
        },
        "resourceGroup": {
          "type": "string",
          "description": "Resource Group."
        },
        "serviceDataAccessAuthIdentity": {
          "description": "Indicates which identity to use to authenticate service data access to customer's storage.",
          "enum": [
            "None",
            "WorkspaceSystemAssignedIdentity"
          ],
          "type": "string",
          "x-ms-enum": {
            "name": "ServiceDataAccessAuthIdentity",
            "modelAsString": true
          }
        }
      }
    },
    "AzureStorageSection": {
      "allOf": [
        {
          "$ref": "#/definitions/AzureResourceDatastore"
        },
        {
          "type": "object",
          "description": "Data specific to azure storage.",
          "properties": {
            "accountName": {
              "type": "string",
              "description": "Storage Account Name."
            },
            "containerName": {
              "type": "string",
              "description": "The storage container name."
            },
            "endpoint": {
              "type": "string",
              "description": "The host of the container."
            },
            "protocol": {
              "type": "string",
              "description": "The protocol to use. Defaults to https."
            },
            "credentialType": {
              "type": "object",
              "$ref": "#/definitions/AzureStorageCredentialTypes"
            },
            "credential": {
              "type": "string",
              "description": "The credential."
            },
            "clientCredentials": {
              "type": "object",
              "$ref": "#/definitions/ClientCredentials"
            },
            "blobCacheTimeout": {
              "format": "int32",
              "description": " If this is an \"DataStoreType.AzureBlob\", the length of time (in seconds) to cache files locally after they are accessed (downloaded).",
              "type": "integer"
            },
            "isSas": {
              "description": "Indicate if we are using SAS token or Account Key (Deprecated).",
              "type": "boolean"
            },
            "accountKey": {
              "type": "string",
              "description": " Storage Account Key (Deprecated)."
            },
            "sasToken": {
              "type": "string",
              "description": " SAS Token for the container (Deprecated)."
            },
            "areWorkspaceManagedIdentitiesAllowed": {
              "description": "Indicate if we are using Workspace ManagedIdentities/MSI token (Deprecated).",
              "type": "boolean"
            }
          }
        }
      ]
    },
    "AzureDataLakeSection": {
      "allOf": [
        {
          "$ref": "#/definitions/ClientCredentials"
        },
        {
          "type": "object",
          "description": "Data Specific to azure data lake.",
          "properties": {
            "storeName": {
              "type": "string",
              "description": "The Azure Data Lake store name."
            },
            "credentialType": {
              "type": "object",
              "$ref": "#/definitions/AzureDataLakeCredentialTypes"
            }
          }
        }
      ]
    },
    "AzureSqlDatabaseSection": {
      "allOf": [
        {
          "$ref": "#/definitions/AzureSqlSection"
        },
        {
          "type": "object",
          "description": "Data specific to azure SQL database."
        }
      ]
    },
    "AzurePostgreSqlSection": {
      "allOf": [
        {
          "$ref": "#/definitions/AzureSqlSection"
        },
        {
          "type": "object",
          "description": " Data specific to azure PostgreSQL.",
          "properties": {
            "enableSsl": {
              "type": "boolean",
              "description": "Indicates SSL requirement of Azure Postgresql server."
            }
          }
        }
      ]
    },
    "AzureMySqlSection": {
      "allOf": [
        {
          "$ref": "#/definitions/AzureSqlSection"
        },
        {
          "type": "object",
          "description": "Data specific to azure MySQL."
        }
      ]
    },
    "GlusterFsSection": {
      "type": "object",
      "description": "Data specific to GlusterFS.",
      "properties": {
        "serverAddress": {
          "type": "string",
          "description": "The server address of one of the servers that hosts the GlusterFS. Can be either the IP address or server name.",
          "readOnly": true
        },
        "volumeName": {
          "type": "string",
          "description": "The name of the created GlusterFS volume.",
          "readOnly": true
        }
      }
    },
    "AzureSqlSection": {
      "allOf": [
        {
          "$ref": "#/definitions/ClientCredentials"
        },
        {
          "type": "object",
          "description": "Data specific to Azure SQL.",
          "properties": {
            "serverName": {
              "type": "string",
              "description": "The Azure SQL server name."
            },
            "databaseName": {
              "type": "string",
              "description": "The Azure SQL database name."
            },
            "endpoint": {
              "type": "string",
              "description": "The server host endpoint."
            },
            "userId": {
              "type": "string",
              "description": "The Azure SQL user id."
            },
            "userPassword": {
              "type": "string",
              "description": "The Azure SQL user password."
            },
            "portNumber": {
              "type": "string",
              "description": "/ The Azure SQL port number."
            },
            "credentialType": {
              "type": "object",
              "$ref": "#/definitions/SqlCredentialTypes"
            }
          }
        }
      ]
    },
    "ClientCredentials": {
      "allOf": [
        {
          "$ref": "#/definitions/AzureResourceDatastore"
        },
        {
          "type": "object",
          "description": "Service principal credential when credential type is \"AzureStorageCredentialTypes.ClientCredentials\".",
          "properties": {
            "clientId": {
              "type": "string",
              "description": "The Client ID/Application ID"
            },
            "tenantId": {
              "type": "string",
              "description": "The ID of the tenant the service principal/app belongs to."
            },
            "isCertAuth": {
              "description": " Is it using certificate to authenticate. If false then use client secret.",
              "type": "boolean"
            },
            "certificate": {
              "type": "string",
              "description": "The content of the certificate used for authentication."
            },
            "thumbprint": {
              "type": "string",
              "description": "The thumbprint of the certificate above."
            },
            "clientSecret": {
              "type": "string",
              "description": "The client secret."
            },
            "authorityUrl": {
              "type": "string",
              "description": "The authority URL used for authentication."
            },
            "resourceUri": {
              "type": "string",
              "description": "The resource the service principal/app has access to."
            }
          }
        }
      ]
    },
    "AzureStorageCredentialTypes": {
      "description": " The credential type.",
      "enum": [
        "None",
        "Sas",
        "AccountKey",
        "ClientCredentials"
      ],
      "type": "string",
      "x-ms-enum": {
        "name": "AzureStorageCredentialTypes",
        "modelAsString": true
      }
    },
    "AzureDataLakeCredentialTypes": {
      "description": "The Azure Data Lake credential type.",
      "enum": [
        "None",
        "ServicePrincipal"
      ],
      "type": "string",
      "x-ms-enum": {
        "name": "AzureDataLakeCredentialTypes",
        "modelAsString": true
      }
    },
    "SqlCredentialTypes": {
      "description": "Sql Authentication type.",
      "enum": [
        "SqlAuthentication",
        "ServicePrincipal",
        "None"
      ],
      "type": "string",
      "x-ms-enum": {
        "name": "SqlCredentialTypes",
        "modelAsString": true
      }
    },
    "PaginatedComputeResourcesList": {
      "type": "object",
      "description": "Paginated list of Machine Learning compute objects wrapped in ARM resource envelope.",
      "properties": {
        "value": {
          "type": "array",
          "description": "An array of Machine Learning compute objects wrapped in ARM resource envelope.",
          "items": {
            "$ref": "#/definitions/ComputeResource"
          }
        },
        "nextLink": {
          "type": "string",
          "description": "A continuation link (absolute URI) to the next page of results in the list."
        }
      }
    },
    "ComputeResource": {
      "type": "object",
      "description": "Machine Learning compute object wrapped into ARM resource envelope.",
      "allOf": [
        {
          "$ref": "#/definitions/Resource"
        },
        {
          "type": "object",
          "properties": {
            "properties": {
              "description": "Compute properties",
              "$ref": "#/definitions/Compute"
            }
          }
        }
      ]
    },
    "Compute": {
      "type": "object",
      "description": "Machine Learning compute object.",
      "discriminator": "computeType",
      "properties": {
        "computeType": {
          "description": "The type of compute",
          "$ref": "#/definitions/ComputeType"
        },
        "computeLocation": {
          "description": "Location for the underlying compute",
          "type": "string"
        },
        "provisioningState": {
          "type": "string",
          "description": "The provision state of the cluster. Valid values are Unknown, Updating, Provisioning, Succeeded, and Failed.",
          "enum": [
            "Unknown",
            "Updating",
            "Creating",
            "Deleting",
            "Succeeded",
            "Failed",
            "Canceled"
          ],
          "x-ms-enum": {
            "name": "ProvisioningState",
            "modelAsString": true
          },
          "readOnly": true
        },
        "description": {
          "type": "string",
          "description": "The description of the Machine Learning compute."
        },
        "createdOn": {
          "type": "string",
          "description": "The date and time when the compute was created.",
          "format": "date-time",
          "readOnly": true
        },
        "modifiedOn": {
          "type": "string",
          "description": "The date and time when the compute was last modified.",
          "format": "date-time",
          "readOnly": true
        },
        "resourceId": {
          "type": "string",
          "description": "ARM resource id of the underlying compute"
        },
        "provisioningErrors": {
          "type": "array",
          "description": "Errors during provisioning",
          "items": {
            "$ref": "#/definitions/MachineLearningServiceError"
          },
          "readOnly": true
        },
        "isAttachedCompute": {
          "type": "boolean",
          "description": "Indicating whether the compute was provisioned by user and brought from outside if true, or machine learning service provisioned it if false.",
          "readOnly": true
        }
      },
      "required": [
        "computeType"
      ]
    },
    "AKS": {
      "description": "A Machine Learning compute based on AKS.",
      "allOf": [
        {
          "$ref": "#/definitions/Compute"
        },
        {
          "type": "object",
          "properties": {
            "properties": {
              "type": "object",
              "description": "AKS properties",
              "properties": {
                "clusterFqdn": {
                  "description": "Cluster full qualified domain name",
                  "type": "string"
                },
                "systemServices": {
                  "type": "array",
                  "description": "System services",
                  "items": {
                    "$ref": "#/definitions/SystemService"
                  },
                  "readOnly": true
                },
                "agentCount": {
                  "description": "Number of agents",
                  "type": "integer",
                  "format": "int32",
                  "minimum": 1
                },
                "agentVMSize": {
                  "description": "Agent virtual machine size",
                  "type": "string"
                },
                "sslConfiguration": {
                  "description": "SSL configuration",
                  "$ref": "#/definitions/SslConfiguration"
                },
                "aksNetworkingConfiguration": {
                  "description": "AKS networking configuration for vnet",
                  "$ref": "#/definitions/AksNetworkingConfiguration"
                }
              }
            }
          }
        }
      ],
      "x-ms-discriminator-value": "AKS"
    },
    "AmlCompute": {
      "description": "An Azure Machine Learning compute.",
      "allOf": [
        {
          "$ref": "#/definitions/Compute"
        },
        {
          "type": "object",
          "properties": {
            "properties": {
              "type": "object",
              "description": "AML Compute properties",
              "properties": {
                "vmSize": {
                  "description": "Virtual Machine Size",
                  "type": "string"
                },
                "vmPriority": {
                  "description": "Virtual Machine priority",
                  "type": "string",
                  "enum": [
                    "Dedicated",
                    "LowPriority"
                  ],
                  "x-ms-enum": {
                    "name": "VmPriority",
                    "modelAsString": true
                  }
                },
                "scaleSettings": {
                  "description": "Scale settings for AML Compute",
                  "$ref": "#/definitions/ScaleSettings"
                },
                "userAccountCredentials": {
                  "title": "User account credentials.",
                  "description": "Credentials for an administrator user account that will be created on each compute node.",
                  "$ref": "#/definitions/UserAccountCredentials"
                },
                "subnet": {
                  "title": "Subnet.",
                  "description": "Virtual network subnet resource ID the compute nodes belong to.",
                  "$ref": "#/definitions/ResourceId"
                },
                "remoteLoginPortPublicAccess": {
                  "type": "string",
                  "default": "NotSpecified",
                  "title": "Close remote Login Access Port",
                  "description": "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.",
                  "enum": [
                    "Enabled",
                    "Disabled",
                    "NotSpecified"
                  ],
                  "x-ms-enum": {
                    "name": "remoteLoginPortPublicAccess",
                    "modelAsString": true
                  }
                },
                "allocationState": {
                  "type": "string",
                  "readOnly": true,
                  "title": "Allocation state.",
                  "description": "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.",
                  "enum": [
                    "Steady",
                    "Resizing"
                  ],
                  "x-ms-enum": {
                    "name": "AllocationState",
                    "modelAsString": true
                  }
                },
                "allocationStateTransitionTime": {
                  "type": "string",
                  "readOnly": true,
                  "format": "date-time",
                  "title": "Allocation state transition time.",
                  "description": "The time at which the compute entered its current allocation state."
                },
                "errors": {
                  "readOnly": true,
                  "title": "Errors.",
                  "description": "Collection of errors encountered by various compute nodes during node setup.",
                  "type": "array",
                  "items": {
                    "$ref": "#/definitions/MachineLearningServiceError"
                  }
                },
                "currentNodeCount": {
                  "type": "integer",
                  "readOnly": true,
                  "format": "int32",
                  "title": "Current node count.",
                  "description": "The number of compute nodes currently assigned to the compute."
                },
                "targetNodeCount": {
                  "type": "integer",
                  "readOnly": true,
                  "format": "int32",
                  "title": "Target node count.",
                  "description": "The target number of compute nodes for the compute. If the allocationState is resizing, this property denotes the target node count for the ongoing resize operation. If the allocationState is steady, this property denotes the target node count for the previous resize operation."
                },
                "nodeStateCounts": {
                  "title": "Node state counts.",
                  "description": "Counts of various node states on the compute.",
                  "readOnly": true,
                  "$ref": "#/definitions/NodeStateCounts"
                }
              }
            }
          }
        }
      ],
      "x-ms-discriminator-value": "AmlCompute"
    },
    "VirtualMachine": {
      "description": "A Machine Learning compute based on Azure Virtual Machines.",
      "allOf": [
        {
          "$ref": "#/definitions/Compute"
        },
        {
          "type": "object",
          "properties": {
            "properties": {
              "type": "object",
              "properties": {
                "virtualMachineSize": {
                  "description": "Virtual Machine size",
                  "type": "string"
                },
                "sshPort": {
                  "description": "Port open for ssh connections.",
                  "type": "integer",
                  "format": "int32"
                },
                "address": {
                  "description": "Public IP address of the virtual machine.",
                  "type": "string"
                },
                "administratorAccount": {
                  "description": "Admin credentials for virtual machine",
                  "$ref": "#/definitions/VirtualMachineSshCredentials"
                }
              }
            }
          }
        }
      ],
      "x-ms-discriminator-value": "VirtualMachine"
    },
    "HDInsight": {
      "description": "A HDInsight compute.",
      "allOf": [
        {
          "$ref": "#/definitions/Compute"
        },
        {
          "type": "object",
          "properties": {
            "properties": {
              "type": "object",
              "properties": {
                "sshPort": {
                  "description": "Port open for ssh connections on the master node of the cluster.",
                  "type": "integer",
                  "format": "int32"
                },
                "address": {
                  "description": "Public IP address of the master node of the cluster.",
                  "type": "string"
                },
                "administratorAccount": {
                  "description": "Admin credentials for master node of the cluster",
                  "$ref": "#/definitions/VirtualMachineSshCredentials"
                }
              }
            }
          }
        }
      ],
      "x-ms-discriminator-value": "HDInsight"
    },
    "DataFactory": {
      "description": "A DataFactory compute.",
      "allOf": [
        {
          "$ref": "#/definitions/Compute"
        }
      ],
      "x-ms-discriminator-value": "DataFactory"
    },
    "Databricks": {
      "description": "A DataFactory compute.",
      "allOf": [
        {
          "$ref": "#/definitions/Compute"
        },
        {
          "type": "object",
          "properties": {
            "properties": {
              "type": "object",
              "properties": {
                "databricksAccessToken": {
                  "description": "Databricks access token",
                  "type": "string"
                }
              }
            }
          }
        }
      ],
      "x-ms-discriminator-value": "Databricks"
    },
    "DataLakeAnalytics": {
      "description": "A DataLakeAnalytics compute.",
      "allOf": [
        {
          "$ref": "#/definitions/Compute"
        },
        {
          "type": "object",
          "properties": {
            "properties": {
              "type": "object",
              "properties": {
                "dataLakeStoreAccountName": {
                  "description": "DataLake Store Account Name",
                  "type": "string"
                }
              }
            }
          }
        }
      ],
      "x-ms-discriminator-value": "DataLakeAnalytics"
    },
    "ServicePrincipalCredentials": {
      "type": "object",
      "description": "Service principal credentials.",
      "properties": {
        "clientId": {
          "description": "Client Id",
          "type": "string"
        },
        "clientSecret": {
          "description": "Client secret",
          "type": "string"
        }
      },
      "required": [
        "clientId",
        "clientSecret"
      ]
    },
    "SystemService": {
      "type": "object",
      "description": "A system service running on a compute.",
      "properties": {
        "systemServiceType": {
          "description": "The type of this system service.",
          "readOnly": true,
          "type": "string"
        },
        "publicIpAddress": {
          "type": "string",
          "description": "Public IP address",
          "readOnly": true
        },
        "version": {
          "description": "The version for this type.",
          "readOnly": true,
          "type": "string"
        }
      }
    },
    "SslConfiguration": {
      "type": "object",
      "description": "The ssl configuration for scoring",
      "properties": {
        "status": {
          "description": "Enable or disable ssl for scoring",
          "type": "string",
          "enum": [
            "Disabled",
            "Enabled"
          ]
        },
        "cert": {
          "description": "Cert data",
          "type": "string"
        },
        "key": {
          "description": "Key data",
          "type": "string"
        },
        "cname": {
          "description": "CNAME of the cert",
          "type": "string"
        }
      }
    },
    "AksNetworkingConfiguration": {
      "type": "object",
      "description": "Advance configuration for AKS networking",
      "properties": {
        "subnetId": {
          "description": "Virtual network subnet resource ID the compute nodes belong to",
          "type": "string"
        },
        "serviceCidr": {
          "pattern": "^([0-9]{1,3}\\.){3}[0-9]{1,3}(\\/([0-9]|[1-2][0-9]|3[0-2]))?$",
          "description": "A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.",
          "type": "string"
        },
        "dnsServiceIP": {
          "pattern": "^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$",
          "description": "An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified in serviceCidr.",
          "type": "string"
        },
        "dockerBridgeCidr": {
          "pattern": "^([0-9]{1,3}\\.){3}[0-9]{1,3}(\\/([0-9]|[1-2][0-9]|3[0-2]))?$",
          "description": "A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes service address range.",
          "type": "string"
        }
      }
    },
    "UserAccountCredentials": {
      "properties": {
        "adminUserName": {
          "type": "string",
          "title": "User name.",
          "description": "Name of the administrator user account which can be used to SSH to nodes."
        },
        "adminUserSshPublicKey": {
          "type": "string",
          "title": "SSH public key.",
          "description": "SSH public key of the administrator user account."
        },
        "adminUserPassword": {
          "type": "string",
          "title": "Password.",
          "description": "Password of the administrator user account."
        }
      },
      "required": [
        "adminUserName"
      ],
      "description": "Settings for user account that gets created on each on the nodes of a compute."
    },
    "ScaleSettings": {
      "type": "object",
      "description": "scale settings for AML Compute",
      "properties": {
        "maxNodeCount": {
          "description": "Max number of nodes to use",
          "type": "integer",
          "format": "int32"
        },
        "minNodeCount": {
          "description": "Min number of nodes to use",
          "type": "integer",
          "format": "int32",
          "default": 0
        },
        "nodeIdleTimeBeforeScaleDown": {
          "type": "string",
          "format": "duration",
          "description": "Node Idle Time before scaling down amlCompute"
        }
      },
      "required": [
        "maxNodeCount"
      ]
    },
    "NodeStateCounts": {
      "properties": {
        "idleNodeCount": {
          "readOnly": true,
          "type": "integer",
          "format": "int32",
          "title": "Idle node count.",
          "description": "Number of compute nodes in idle state."
        },
        "runningNodeCount": {
          "readOnly": true,
          "type": "integer",
          "format": "int32",
          "title": "Running node count.",
          "description": "Number of compute nodes which are running jobs."
        },
        "preparingNodeCount": {
          "readOnly": true,
          "type": "integer",
          "format": "int32",
          "title": "Preparing node count.",
          "description": "Number of compute nodes which are being prepared."
        },
        "unusableNodeCount": {
          "readOnly": true,
          "type": "integer",
          "format": "int32",
          "title": "Unusable node count.",
          "description": "Number of compute nodes which are in unusable state."
        },
        "leavingNodeCount": {
          "readOnly": true,
          "type": "integer",
          "format": "int32",
          "title": "Leaving node count.",
          "description": "Number of compute nodes which are leaving the amlCompute."
        },
        "preemptedNodeCount": {
          "readOnly": true,
          "type": "integer",
          "format": "int32",
          "title": "Preempted node count.",
          "description": "Number of compute nodes which are in preempted state."
        }
      },
      "description": "Counts of various compute node states on the amlCompute."
    },
    "ClusterUpdateProperties": {
      "properties": {
        "scaleSettings": {
          "$ref": "#/definitions/ScaleSettings",
          "title": "Scale settings.",
          "description": "Desired scale settings for the amlCompute."
        }
      },
      "description": "The properties of a amlCompute that need to be updated."
    },
    "ClusterUpdateParameters": {
      "properties": {
        "properties": {
          "x-ms-client-flatten": true,
          "$ref": "#/definitions/ClusterUpdateProperties",
          "description": "The properties of the amlCompute."
        }
      },
      "description": "AmlCompute update parameters."
    },
    "ComputeNodesInformation": {
      "type": "object",
      "description": "Compute nodes information related to a Machine Learning compute. Might differ for every type of compute.",
      "discriminator": "computeType",
      "properties": {
        "computeType": {
          "description": "The type of compute",
          "$ref": "#/definitions/ComputeType"
        },
        "nextLink": {
          "readOnly": true,
          "type": "string",
          "description": "The continuation token."
        }
      },
      "required": [
        "computeType"
      ]
    },
    "AmlComputeNodesInformation": {
      "description": "Compute node information related to a AmlCompute.",
      "allOf": [
        {
          "$ref": "#/definitions/ComputeNodesInformation"
        },
        {
          "type": "object",
          "properties": {
            "nodes": {
              "readOnly": true,
              "type": "array",
              "items": {
                "$ref": "#/definitions/AmlComputeNodeInformation"
              },
              "description": "The collection of returned AmlCompute nodes details."
            }
          }
        }
      ],
      "x-ms-discriminator-value": "AmlCompute"
    },
    "AmlComputeNodeInformation": {
      "description": "Compute node information related to a AmlCompute.",
      "properties": {
        "nodeId": {
          "readOnly": true,
          "type": "string",
          "title": "Node ID.",
          "description": "ID of the compute node."
        },
        "privateIpAddress": {
          "readOnly": true,
          "type": "string",
          "title": "Private IP address.",
          "description": "Private IP address of the compute node."
        },
        "publicIpAddress": {
          "readOnly": true,
          "type": "string",
          "title": "Public IP address.",
          "description": "Public IP address of the compute node."
        },
        "port": {
          "readOnly": true,
          "type": "number",
          "format": "int32",
          "title": "Port.",
          "description": "SSH port number of the node."
        },
        "nodeState": {
          "readOnly": true,
          "type": "string",
          "enum": [
            "idle",
            "running",
            "preparing",
            "unusable",
            "leaving",
            "preempted"
          ],
          "description": "State of the compute node. Values are idle, running, preparing, unusable, leaving and preempted.",
          "x-ms-enum": {
            "name": "nodeState",
            "modelAsString": true
          }
        },
        "runId": {
          "readOnly": true,
          "type": "string",
          "title": "Run ID.",
          "description": "ID of the Experiment running on the node, if any else null."
        }
      },
      "x-ms-discriminator-value": "AmlCompute"
    },
    "VirtualMachineSshCredentials": {
      "type": "object",
      "description": "Admin credentials for virtual machine",
      "properties": {
        "username": {
          "description": "Username of admin account",
          "type": "string"
        },
        "password": {
          "description": "Password of admin account",
          "type": "string"
        },
        "publicKeyData": {
          "description": "Public key data",
          "type": "string"
        },
        "privateKeyData": {
          "description": "Private key data",
          "type": "string"
        }
      }
    },
    "ComputeSecrets": {
      "type": "object",
      "description": "Secrets related to a Machine Learning compute. Might differ for every type of compute.",
      "discriminator": "computeType",
      "properties": {
        "computeType": {
          "description": "The type of compute",
          "$ref": "#/definitions/ComputeType"
        }
      },
      "required": [
        "computeType"
      ]
    },
    "AksComputeSecrets": {
      "description": "Secrets related to a Machine Learning compute based on AKS.",
      "allOf": [
        {
          "$ref": "#/definitions/ComputeSecrets"
        },
        {
          "type": "object",
          "properties": {
            "userKubeConfig": {
              "type": "string",
              "description": "Content of kubeconfig file that can be used to connect to the Kubernetes cluster."
            },
            "adminKubeConfig": {
              "type": "string",
              "description": "Content of kubeconfig file that can be used to connect to the Kubernetes cluster."
            },
            "imagePullSecretName": {
              "type": "string",
              "description": "Image registry pull secret."
            }
          }
        }
      ],
      "x-ms-discriminator-value": "AKS"
    },
    "VirtualMachineSecrets": {
      "description": "Secrets related to a Machine Learning compute based on AKS.",
      "allOf": [
        {
          "$ref": "#/definitions/ComputeSecrets"
        },
        {
          "type": "object",
          "properties": {
            "administratorAccount": {
              "description": "Admin credentials for virtual machine.",
              "$ref": "#/definitions/VirtualMachineSshCredentials"
            }
          }
        }
      ],
      "x-ms-discriminator-value": "VirtualMachine"
    },
    "DatabricksComputeSecrets": {
      "description": "Secrets related to a Machine Learning compute based on Databricks.",
      "allOf": [
        {
          "$ref": "#/definitions/ComputeSecrets"
        },
        {
          "type": "object",
          "properties": {
            "databricksAccessToken": {
              "description": "access token for databricks account.",
              "type": "string"
            }
          }
        }
      ],
      "x-ms-discriminator-value": "Databricks"
    },
    "ComputeType": {
      "type": "string",
      "description": "The type of compute",
      "enum": [
        "AKS",
        "AmlCompute",
        "DataFactory",
        "VirtualMachine",
        "HDInsight",
        "Databricks",
        "DataLakeAnalytics"
      ],
      "x-ms-enum": {
        "name": "ComputeType",
        "modelAsString": true
      }
    },
    "MachineLearningServiceError": {
      "type": "object",
      "description": "Wrapper for error response to follow ARM guidelines.",
      "properties": {
        "error": {
          "description": "The error response.",
          "$ref": "#/definitions/ErrorResponse",
          "readOnly": true
        }
      }
    },
    "ErrorResponse": {
      "type": "object",
      "description": "Error response information.",
      "properties": {
        "code": {
          "type": "string",
          "description": "Error code.",
          "readOnly": true
        },
        "message": {
          "type": "string",
          "description": "Error message.",
          "readOnly": true
        },
        "details": {
          "type": "array",
          "description": "An array of error detail objects.",
          "items": {
            "$ref": "#/definitions/ErrorDetail"
          },
          "readOnly": true
        }
      }
    },
    "ErrorDetail": {
      "type": "object",
      "description": "Error detail information.",
      "properties": {
        "code": {
          "type": "string",
          "description": "Error code."
        },
        "message": {
          "type": "string",
          "description": "Error message."
        }
      },
      "required": [
        "code",
        "message"
      ]
    },
    "SKUCapability": {
      "description": "Features/user capabilities associated with the sku",
      "type": "object",
      "properties": {
        "name": {
          "description": "Capability/Feature ID",
          "type": "string"
        },
        "value": {
          "description": "Details about the feature/capability",
          "type": "string"
        }
      }
    },
    "ResourceSkuLocationInfo": {
      "properties": {
        "location": {
          "readOnly": true,
          "type": "string",
          "description": "Location of the SKU"
        },
        "zones": {
          "readOnly": true,
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "List of availability zones where the SKU is supported."
        },
        "zoneDetails": {
          "readOnly": true,
          "type": "array",
          "items": {
            "$ref": "#/definitions/ResourceSkuZoneDetails"
          },
          "description": "Details of capabilities available to a SKU in specific zones."
        }
      }
    },
    "ResourceSkuZoneDetails": {
      "properties": {
        "name": {
          "type": "array",
          "readOnly": true,
          "items": {
            "type": "string"
          },
          "description": "The set of zones that the SKU is available in with the specified capabilities."
        },
        "capabilities": {
          "type": "array",
          "readOnly": true,
          "items": {
            "$ref": "#/definitions/SKUCapability"
          },
          "description": "A list of capabilities that are available for the SKU in the specified list of zones."
        }
      },
      "description": "Describes The zonal capabilities of a SKU."
    },
    "WorkspaceSku": {
      "description": "Describes Workspace Sku details and features",
      "type": "object",
      "properties": {
        "locations": {
          "readOnly": true,
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "The set of locations that the SKU is available. This will be supported and registered Azure Geo Regions (e.g. West US, East US, Southeast Asia, etc.)."
        },
        "locationInfo": {
          "type": "array",
          "readOnly": true,
          "items": {
            "$ref": "#/definitions/ResourceSkuLocationInfo"
          },
          "description": "A list of locations and availability zones in those locations where the SKU is available."
        },
        "tier": {
          "description": "Sku Tier like Basic or Enterprise",
          "type": "string",
          "readOnly": true
        },
        "resourceType": {
          "type": "string",
          "readOnly": true
        },
        "name": {
          "type": "string",
          "readOnly": true
        },
        "capabilities": {
          "description": "List of features/user capabilities associated with the sku",
          "uniqueItems": false,
          "type": "array",
          "items": {
            "$ref": "#/definitions/SKUCapability"
          },
          "readOnly": true
        },
        "restrictions": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/Restriction"
          },
          "description": "The restrictions because of which SKU cannot be used. This is empty if there are no restrictions."
        }
      }
    },
    "Restriction": {
      "properties": {
        "type": {
          "readOnly": true,
          "type": "string",
          "description": "The type of restrictions. As of now only possible value for this is location."
        },
        "values": {
          "readOnly": true,
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "The value of restrictions. If the restriction type is set to location. This would be different locations where the SKU is restricted."
        },
        "reasonCode": {
          "type": "string",
          "enum": [
            "NotSpecified",
            "NotAvailableForRegion",
            "NotAvailableForSubscription"
          ],
          "x-ms-enum": {
            "name": "ReasonCode",
            "modelAsString": true
          },
          "description": "The reason for the restriction."
        }
      },
      "description": "The restriction because of which SKU cannot be used."
    },
    "SkuListResult": {
      "description": "List of skus with features",
      "type": "object",
      "properties": {
        "value": {
          "uniqueItems": false,
          "type": "array",
          "items": {
            "$ref": "#/definitions/WorkspaceSku"
          }
        },
        "nextLink": {
          "type": "string",
          "description": "The URI to fetch the next page of Workspace Skus. Call ListNext() with this URI to fetch the next page of Workspace Skus"
        }
      }
    },
    "Sku": {
      "description": "Sku of the resource",
      "type": "object",
      "properties": {
        "name": {
          "description": "Name of the sku",
          "type": "string"
        },
        "tier": {
          "description": "Tier of the sku like Basic or Enterprise",
          "type": "string"
        }
      }
    },
    "PrivateEndpointConnection": {
      "properties": {
        "properties": {
          "$ref": "#/definitions/PrivateEndpointConnectionProperties",
          "x-ms-client-flatten": true,
          "description": "Resource properties."
        }
      },
      "allOf": [
        {
          "$ref": "#/definitions/Resource"
        }
      ],
      "description": "The Private Endpoint Connection resource."
    },
    "PrivateEndpointConnectionProperties": {
      "properties": {
        "privateEndpoint": {
          "$ref": "#/definitions/PrivateEndpoint",
          "description": "The resource of private end point."
        },
        "privateLinkServiceConnectionState": {
          "$ref": "#/definitions/PrivateLinkServiceConnectionState",
          "description": "A collection of information about the state of the connection between service consumer and provider."
        },
        "provisioningState": {
          "$ref": "#/definitions/PrivateEndpointConnectionProvisioningState",
          "description": "The provisioning state of the private endpoint connection resource."
        }
      },
      "required": [
        "privateLinkServiceConnectionState"
      ],
      "description": "Properties of the PrivateEndpointConnectProperties."
    },
    "PrivateEndpoint": {
      "properties": {
        "id": {
          "readOnly": true,
          "type": "string",
          "description": "The ARM identifier for Private Endpoint"
        }
      },
      "description": "The Private Endpoint resource."
    },
    "PrivateLinkServiceConnectionState": {
      "properties": {
        "status": {
          "$ref": "#/definitions/PrivateEndpointServiceConnectionStatus",
          "description": "Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service."
        },
        "description": {
          "type": "string",
          "description": "The reason for approval/rejection of the connection."
        },
        "actionsRequired": {
          "type": "string",
          "description": "A message indicating if changes on the service provider require any updates on the consumer."
        }
      },
      "description": "A collection of information about the state of the connection between service consumer and provider."
    },
    "PrivateEndpointServiceConnectionStatus": {
      "type": "string",
      "description": "The private endpoint connection status.",
      "enum": [
        "Pending",
        "Approved",
        "Rejected",
        "Disconnected",
        "Timeout"
      ],
      "x-ms-enum": {
        "name": "PrivateEndpointServiceConnectionStatus",
        "modelAsString": true
      }
    },
    "PrivateEndpointConnectionProvisioningState": {
      "type": "string",
      "readOnly": true,
      "description": "The current provisioning state.",
      "enum": [
        "Succeeded",
        "Creating",
        "Deleting",
        "Failed"
      ],
      "x-ms-enum": {
        "name": "PrivateEndpointConnectionProvisioningState",
        "modelAsString": true
      }
    },
    "PrivateLinkResourceListResult": {
      "properties": {
        "value": {
          "type": "array",
          "description": "Array of private link resources",
          "items": {
            "$ref": "#/definitions/PrivateLinkResource"
          }
        }
      },
      "description": "A list of private link resources"
    },
    "PrivateLinkResource": {
      "properties": {
        "properties": {
          "$ref": "#/definitions/PrivateLinkResourceProperties",
          "description": "Resource properties.",
          "x-ms-client-flatten": true
        }
      },
      "allOf": [
        {
          "$ref": "#/definitions/Resource"
        }
      ],
      "description": "A private link resource"
    },
    "PrivateLinkResourceProperties": {
      "properties": {
        "groupId": {
          "description": "The private link resource group id.",
          "type": "string",
          "readOnly": true
        },
        "requiredMembers": {
          "description": "The private link resource required member names.",
          "type": "array",
          "items": {
            "type": "string"
          },
          "readOnly": true
        },
        "requiredZoneNames": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "The private link resource Private link DNS zone name."
        }
      },
      "description": "Properties of a private link resource."
    },
    "SharedPrivateLinkResource": {
      "properties": {
        "name": {
          "description": "Unique name of the private link.",
          "type": "string"
        },
        "properties": {
          "$ref": "#/definitions/SharedPrivateLinkResourceProperty",
          "x-ms-client-flatten": true,
          "description": "Resource properties."
        }
      }
    },
    "SharedPrivateLinkResourceProperty": {
      "properties": {
        "privateLinkResourceId": {
          "description": "The resource id that private link links to.",
          "type": "string"
        },
        "groupId": {
          "description": "The private link resource group id.",
          "type": "string"
        },
        "requestMessage": {
          "description": "Request message.",
          "type": "string"
        },
        "status": {
          "$ref": "#/definitions/PrivateEndpointServiceConnectionStatus",
          "description": "Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service."
        }
      },
      "description": "Properties of a shared private link resource."
    },
    "EncryptionProperty": {
      "properties": {
        "status": {
          "description": "Indicates whether or not the encryption is enabled for the workspace.",
          "enum": [
            "Enabled",
            "Disabled"
          ],
          "type": "string",
          "x-ms-enum": {
            "name": "EncryptionStatus",
            "modelAsString": true
          }
        },
        "keyVaultProperties": {
          "$ref": "#/definitions/KeyVaultProperties",
          "description": "Customer Key vault properties."
        }
      },
      "required": [
        "status",
        "keyVaultProperties"
      ],
      "type": "object"
    },
    "KeyVaultProperties": {
      "properties": {
        "keyVaultArmId": {
          "description": "The ArmId of the keyVault where the customer owned encryption key is present.",
          "type": "string"
        },
        "keyIdentifier": {
          "description": "Key vault uri to access the encryption key.",
          "type": "string"
        },
        "identityClientId": {
          "description": "For future use - The client id of the identity which will be used to access key vault.",
          "type": "string"
        }
      },
      "required": [
        "keyIdentifier",
        "keyVaultArmId"
      ],
      "type": "object"
    },
    "LinkedWorkspace": {
      "description": "Linked workspace.",
      "type": "object",
      "x-ms-azure-resource": true,
      "properties": {
        "id": {
          "type": "string",
          "description": "ResourceId of the link of the linked workspace.",
          "readOnly": true
        },
        "name": {
          "type": "string",
          "description": "Friendly name of the linked workspace.",
          "readOnly": true
        },
        "type": {
          "type": "string",
          "description": "Resource type of linked workspace.",
          "readOnly": true
        },
        "properties": {
          "$ref": "#/definitions/LinkedWorkspaceProps"
        }
      }
    },
    "LinkedWorkspaceDto": {
      "type": "object",
      "description": "object used for creating linked workspace.",
      "properties": {
        "name": {
          "description": "Friendly name of the linked workspace",
          "type": "string"
        },
        "properties": {
          "$ref": "#/definitions/LinkedWorkspaceProps"
        }
      }
    },
    "LinkedWorkspaceProps": {
      "type": "object",
      "description": "LinkedWorkspace specific properties.",
      "properties": {
        "linkedWorkspaceResourceId": {
          "description": "ResourceId of the link target of the linked workspace.",
          "type": "string"
        },
        "userAssignedIdentityResourceId": {
          "description": "ResourceId of the user assigned identity for the linked workspace.",
          "type": "string"
        }
      }
    },
    "ServiceResource": {
      "type": "object",
      "description": "Machine Learning service object wrapped into ARM resource envelope.",
      "allOf": [
        {
          "$ref": "#/definitions/Resource"
        },
        {
          "type": "object",
          "properties": {
            "properties": {
              "description": "Service properties",
              "$ref": "#/definitions/ServiceResponseBase"
            }
          }
        }
      ]
    },
    "ServiceResponseBase": {
      "description": "The base service response. The correct inherited response based on computeType will be returned (ex. ACIServiceResponse)",
      "required": [
        "computeType"
      ],
      "type": "object",
      "properties": {
        "description": {
          "description": "The service description.",
          "type": "string"
        },
        "kvTags": {
          "description": "The service tag dictionary. Tags are mutable.",
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        },
        "properties": {
          "description": "The service property dictionary. Properties are immutable.",
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        },
        "state": {
          "description": "The current state of the service.",
          "enum": [
            "Transitioning",
            "Healthy",
            "Unhealthy",
            "Failed",
            "Unschedulable"
          ],
          "type": "string",
          "example": "Healthy",
          "x-ms-enum": {
            "name": "WebServiceState",
            "modelAsString": true
          },
          "readOnly": true
        },
        "error": {
          "description": "The error details.",
          "allOf": [
            {
              "$ref": "#/definitions/ErrorResponse"
            }
          ],
          "readOnly": true
        },
        "computeType": {
          "description": "The compute environment type for the service.",
          "enum": [
            "ACI",
            "AKS"
          ],
          "type": "string",
          "example": "AKS",
          "x-ms-enum": {
            "name": "ComputeEnvironmentType",
            "modelAsString": true
          }
        },
        "deploymentType": {
          "description": "The deployment type for the service.",
          "enum": [
            "GRPCRealtimeEndpoint",
            "HttpRealtimeEndpoint",
            "Batch"
          ],
          "type": "string",
          "example": "HttpRealtimeEndpoint",
          "x-ms-enum": {
            "name": "DeploymentType",
            "modelAsString": true
          }
        }
      },
      "discriminator": "computeType"
    },
    "PaginatedServiceList": {
      "type": "object",
      "description": "Paginated list of Machine Learning service objects wrapped in ARM resource envelope.",
      "properties": {
        "value": {
          "readOnly": true,
          "type": "array",
          "description": "An array of Machine Learning compute objects wrapped in ARM resource envelope.",
          "items": {
            "$ref": "#/definitions/ServiceResource"
          }
        },
        "nextLink": {
          "readOnly": true,
          "type": "string",
          "description": "A continuation link (absolute URI) to the next page of results in the list."
        }
      }
    },
    "ACIServiceResponse": {
      "description": "The response for an ACI service.",
      "type": "object",
      "allOf": [
        {
          "$ref": "#/definitions/ServiceResponseBase"
        },
        {
          "type": "object",
          "properties": {
            "containerResourceRequirements": {
              "description": "The container resource requirements.",
              "$ref": "#/definitions/ContainerResourceRequirements"
            },
            "scoringUri": {
              "description": "The Uri for sending scoring requests.",
              "type": "string",
              "readOnly": true
            },
            "location": {
              "description": "The name of the Azure location/region.",
              "type": "string"
            },
            "authEnabled": {
              "description": "Whether or not authentication is enabled on the service.",
              "type": "boolean"
            },
            "sslEnabled": {
              "description": "Whether or not SSL is enabled.",
              "type": "boolean"
            },
            "appInsightsEnabled": {
              "description": "Whether or not Application Insights is enabled.",
              "type": "boolean"
            },
            "dataCollection": {
              "description": "Details of the data collection options specified.",
              "allOf": [
                {
                  "$ref": "#/definitions/ModelDataCollection"
                }
              ]
            },
            "sslCertificate": {
              "description": "The public SSL certificate in PEM format to use if SSL is enabled.",
              "type": "string"
            },
            "sslKey": {
              "description": "The public SSL key in PEM format for the certificate.",
              "type": "string"
            },
            "cname": {
              "description": "The CName for the service.",
              "type": "string"
            },
            "publicIp": {
              "description": "The public IP address for the service.",
              "type": "string"
            },
            "publicFqdn": {
              "description": "The public Fqdn for the service.",
              "type": "string"
            },
            "swaggerUri": {
              "description": "The Uri for sending swagger requests.",
              "type": "string",
              "readOnly": true
            },
            "modelConfigMap": {
              "description": "Details on the models and configurations.",
              "type": "object",
              "additionalProperties": {
                "type": "object"
              },
              "readOnly": true
            },
            "models": {
              "description": "The list of models.",
              "type": "array",
              "items": {
                "$ref": "#/definitions/Model"
              }
            },
            "environmentImageRequest": {
              "description": "The Environment, models and assets used for inferencing.",
              "allOf": [
                {
                  "$ref": "#/definitions/EnvironmentImageResponse"
                }
              ]
            },
            "vnetConfiguration": {
              "description": "The virtual network configuration.",
              "allOf": [
                {
                  "$ref": "#/definitions/VnetConfiguration"
                }
              ]
            },
            "encryptionProperties": {
              "description": "The encryption properties.",
              "allOf": [
                {
                  "$ref": "#/definitions/EncryptionProperties"
                }
              ]
            }
          }
        }
      ],
      "x-ms-discriminator-value": "ACI"
    },
    "ContainerResourceRequirements": {
      "description": "The resource requirements for the container (cpu and memory).",
      "type": "object",
      "properties": {
        "cpu": {
          "format": "double",
          "description": "The number of CPU cores on the container.",
          "type": "number",
          "example": 4
        },
        "memoryInGB": {
          "format": "double",
          "description": "The amount of memory on the container in GB.",
          "type": "number",
          "example": 64
        },
        "gpu": {
          "format": "int32",
          "description": "The number of GPU cores in the container.",
          "type": "integer"
        },
        "fpga": {
          "format": "int32",
          "description": "The number of FPGA PCIE devices exposed to the container. Must be multiple of 2.",
          "type": "integer"
        }
      }
    },
    "ModelDataCollection": {
      "description": "The Model data collection properties.",
      "type": "object",
      "properties": {
        "eventHubEnabled": {
          "description": "Option for enabling/disabling Event Hub.",
          "type": "boolean"
        },
        "storageEnabled": {
          "description": "Option for enabling/disabling storage.",
          "type": "boolean"
        }
      }
    },
    "VnetConfiguration": {
      "type": "object",
      "properties": {
        "vnetName": {
          "description": "The name of the virtual network.",
          "type": "string"
        },
        "subnetName": {
          "description": "The name of the virtual network subnet.",
          "type": "string"
        }
      }
    },
    "EncryptionProperties": {
      "type": "object",
      "properties": {
        "vaultBaseUrl": {
          "description": "vault base Url",
          "type": "string"
        },
        "keyName": {
          "description": "Encryption Key name",
          "type": "string"
        },
        "keyVersion": {
          "description": "Encryption Key Version",
          "type": "string"
        }
      },
      "required": [
        "vaultBaseUrl",
        "keyName",
        "keyVersion"
      ]
    },
    "Model": {
      "description": "An Azure Machine Learning Model.",
      "required": [
        "mimeType",
        "name",
        "url"
      ],
      "type": "object",
      "properties": {
        "id": {
          "description": "The Model Id.",
          "type": "string",
          "example": "sklearn_mnist:1"
        },
        "name": {
          "description": "The Model name.",
          "type": "string",
          "example": "sklearn_mnist"
        },
        "framework": {
          "description": "The Model framework.",
          "type": "string"
        },
        "frameworkVersion": {
          "description": "The Model framework version.",
          "type": "string"
        },
        "version": {
          "format": "int64",
          "description": "The Model version assigned by Model Management Service.",
          "type": "integer",
          "example": 1
        },
        "datasets": {
          "description": "The list of datasets associated with the model.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/DatasetReference"
          }
        },
        "url": {
          "description": "The URL of the Model. Usually a SAS URL.",
          "type": "string"
        },
        "mimeType": {
          "description": "The MIME type of Model content. For more details about MIME type, please open https://www.iana.org/assignments/media-types/media-types.xhtml",
          "type": "string"
        },
        "description": {
          "description": "The Model description text.",
          "type": "string",
          "example": "A mnist model, first version."
        },
        "createdTime": {
          "format": "date-time",
          "description": "The Model creation time (UTC).",
          "type": "string"
        },
        "modifiedTime": {
          "format": "date-time",
          "description": "The Model last modified time (UTC).",
          "type": "string"
        },
        "unpack": {
          "description": "Indicates whether we need to unpack the Model during docker Image creation.",
          "type": "boolean"
        },
        "parentModelId": {
          "description": "The Parent Model Id.",
          "type": "string",
          "example": "sklearn_mnist_root:1"
        },
        "runId": {
          "description": "The RunId that created this model.",
          "type": "string"
        },
        "experimentName": {
          "description": "The name of the experiment where this model was created.",
          "type": "string"
        },
        "kvTags": {
          "description": "The Model tag dictionary. Items are mutable.",
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        },
        "properties": {
          "description": "The Model property dictionary. Properties are immutable.",
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        },
        "derivedModelIds": {
          "description": "Models derived from this model",
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "sampleInputData": {
          "description": "Sample Input Data for the Model. A reference to a dataset in the workspace in the format aml://dataset/{datasetId}",
          "type": "string"
        },
        "sampleOutputData": {
          "description": "Sample Output Data for the Model. A reference to a dataset in the workspace in the format aml://dataset/{datasetId}",
          "type": "string"
        },
        "resourceRequirements": {
          "description": "Resource requirements for the model",
          "$ref": "#/definitions/ContainerResourceRequirements"
        }
      }
    },
    "EnvironmentImageRequest": {
      "description": "Request to create a Docker image based on Environment.",
      "type": "object",
      "properties": {
        "driverProgram": {
          "description": "The name of the driver file.",
          "type": "string"
        },
        "assets": {
          "description": "The list of assets.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ImageAsset"
          }
        },
        "modelIds": {
          "description": "The list of model Ids.",
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "models": {
          "description": "The list of models.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/Model"
          }
        },
        "environment": {
          "description": "The details of the AZURE ML environment.",
          "allOf": [
            {
              "$ref": "#/definitions/ModelEnvironmentDefinition"
            }
          ]
        },
        "environmentReference": {
          "description": "The unique identifying details of the AZURE ML environment.",
          "allOf": [
            {
              "$ref": "#/definitions/EnvironmentReference"
            }
          ]
        }
      }
    },
    "EnvironmentImageResponse": {
      "description": "Request to create a Docker image based on Environment.",
      "type": "object",
      "properties": {
        "driverProgram": {
          "description": "The name of the driver file.",
          "type": "string"
        },
        "assets": {
          "description": "The list of assets.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ImageAsset"
          }
        },
        "modelIds": {
          "description": "The list of model Ids.",
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "models": {
          "description": "The list of models.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/Model"
          }
        },
        "environment": {
          "description": "The details of the AZURE ML environment.",
          "allOf": [
            {
              "$ref": "#/definitions/ModelEnvironmentDefinitionResponse"
            }
          ]
        },
        "environmentReference": {
          "description": "The unique identifying details of the AZURE ML environment.",
          "allOf": [
            {
              "$ref": "#/definitions/EnvironmentReference"
            }
          ]
        }
      }
    },
    "ImageAsset": {
      "description": "An Image asset.",
      "type": "object",
      "properties": {
        "id": {
          "description": "The Asset Id.",
          "type": "string"
        },
        "mimeType": {
          "description": "The mime type.",
          "type": "string"
        },
        "url": {
          "description": "The Url of the Asset.",
          "type": "string"
        },
        "unpack": {
          "description": "Whether the Asset is unpacked.",
          "type": "boolean"
        }
      }
    },
    "ModelEnvironmentDefinition": {
      "type": "object",
      "properties": {
        "name": {
          "description": "The name of the environment.",
          "type": "string",
          "example": "mydevenvironment"
        },
        "version": {
          "description": "The environment version.",
          "type": "string",
          "example": "1"
        },
        "python": {
          "description": "Settings for a Python environment.",
          "allOf": [
            {
              "$ref": "#/definitions/ModelPythonSection"
            }
          ]
        },
        "environmentVariables": {
          "description": "Definition of environment variables to be defined in the environment.",
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        },
        "docker": {
          "description": "The definition of a Docker container.",
          "allOf": [
            {
              "$ref": "#/definitions/ModelDockerSection"
            }
          ]
        },
        "spark": {
          "description": "The configuration for a Spark environment.",
          "allOf": [
            {
              "$ref": "#/definitions/ModelSparkSection"
            }
          ]
        },
        "r": {
          "description": "Settings for a R environment.",
          "allOf": [
            {
              "$ref": "#/definitions/RSection"
            }
          ]
        },
        "inferencingStackVersion": {
          "description": "The inferencing stack version added to the image. To avoid adding an inferencing stack, do not set this value. Valid values: \"latest\".",
          "type": "string",
          "example": "latest"
        }
      }
    },
    "ModelEnvironmentDefinitionResponse": {
      "type": "object",
      "properties": {
        "name": {
          "description": "The name of the environment.",
          "type": "string",
          "example": "mydevenvironment"
        },
        "version": {
          "description": "The environment version.",
          "type": "string",
          "example": "1"
        },
        "python": {
          "description": "Settings for a Python environment.",
          "allOf": [
            {
              "$ref": "#/definitions/ModelPythonSection"
            }
          ]
        },
        "environmentVariables": {
          "description": "Definition of environment variables to be defined in the environment.",
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        },
        "docker": {
          "description": "The definition of a Docker container.",
          "allOf": [
            {
              "$ref": "#/definitions/ModelDockerSectionResponse"
            }
          ]
        },
        "spark": {
          "description": "The configuration for a Spark environment.",
          "allOf": [
            {
              "$ref": "#/definitions/ModelSparkSection"
            }
          ]
        },
        "r": {
          "description": "Settings for a R environment.",
          "allOf": [
            {
              "$ref": "#/definitions/RSectionResponse"
            }
          ]
        },
        "inferencingStackVersion": {
          "description": "The inferencing stack version added to the image. To avoid adding an inferencing stack, do not set this value. Valid values: \"latest\".",
          "type": "string",
          "example": "latest"
        }
      }
    },
    "EnvironmentReference": {
      "type": "object",
      "properties": {
        "name": {
          "description": "Name of the environment.",
          "type": "string"
        },
        "version": {
          "description": "Version of the environment.",
          "type": "string"
        }
      }
    },
    "ModelPythonSection": {
      "type": "object",
      "properties": {
        "interpreterPath": {
          "description": "The python interpreter path to use if an environment build is not required. The path specified gets used to call the user script.",
          "type": "string"
        },
        "userManagedDependencies": {
          "description": "True means that AzureML reuses an existing python environment; False means that AzureML will create a python environment based on the Conda dependencies specification.",
          "type": "boolean"
        },
        "condaDependencies": {
          "description": "A JObject containing Conda dependencies.",
          "type": "object"
        },
        "baseCondaEnvironment": {
          "type": "string"
        }
      }
    },
    "ContainerRegistry": {
      "type": "object",
      "properties": {
        "address": {
          "type": "string"
        },
        "username": {
          "type": "string",
          "x-ms-secret": true
        },
        "password": {
          "type": "string",
          "x-ms-secret": true
        }
      }
    },
    "ContainerRegistryResponse": {
      "type": "object",
      "properties": {
        "address": {
          "type": "string"
        }
      }
    },
    "ModelDockerSection": {
      "type": "object",
      "properties": {
        "baseImage": {
          "description": "Base image used for Docker-based runs. Mutually exclusive with BaseDockerfile.",
          "type": "string",
          "example": "ubuntu:latest"
        },
        "baseDockerfile": {
          "description": "Base Dockerfile used for Docker-based runs. Mutually exclusive with BaseImage.",
          "type": "string",
          "example": "FROM ubuntu:latest\r\nRUN echo \"Hello world!\""
        },
        "baseImageRegistry": {
          "description": "Image registry that contains the base image.",
          "allOf": [
            {
              "$ref": "#/definitions/ContainerRegistry"
            }
          ]
        }
      }
    },
    "ModelDockerSectionResponse": {
      "type": "object",
      "properties": {
        "baseImage": {
          "description": "Base image used for Docker-based runs. Mutually exclusive with BaseDockerfile.",
          "type": "string",
          "example": "ubuntu:latest"
        },
        "baseDockerfile": {
          "description": "Base Dockerfile used for Docker-based runs. Mutually exclusive with BaseImage.",
          "type": "string",
          "example": "FROM ubuntu:latest\r\nRUN echo \"Hello world!\""
        },
        "baseImageRegistry": {
          "description": "Image registry that contains the base image.",
          "allOf": [
            {
              "$ref": "#/definitions/ContainerRegistryResponse"
            }
          ]
        }
      }
    },
    "SparkMavenPackage": {
      "type": "object",
      "properties": {
        "group": {
          "type": "string"
        },
        "artifact": {
          "type": "string"
        },
        "version": {
          "type": "string"
        }
      }
    },
    "ModelSparkSection": {
      "type": "object",
      "properties": {
        "repositories": {
          "description": "The list of spark repositories.",
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "packages": {
          "description": "The Spark packages to use.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/SparkMavenPackage"
          }
        },
        "precachePackages": {
          "description": "Whether to precache the packages.",
          "type": "boolean"
        }
      }
    },
    "RCranPackage": {
      "type": "object",
      "properties": {
        "name": {
          "description": "The package name.",
          "type": "string"
        },
        "repository": {
          "description": "The repository name.",
          "type": "string"
        }
      }
    },
    "RGitHubPackage": {
      "type": "object",
      "properties": {
        "repository": {
          "description": "Repository address in the format username/repo[/subdir][@ref|#pull].",
          "type": "string"
        },
        "authToken": {
          "description": "Personal access token to install from a private repo",
          "type": "string",
          "x-ms-secret": true
        }
      }
    },
    "RGitHubPackageResponse": {
      "type": "object",
      "properties": {
        "repository": {
          "description": "Repository address in the format username/repo[/subdir][@ref|#pull].",
          "type": "string"
        }
      }
    },
    "RSection": {
      "type": "object",
      "properties": {
        "rVersion": {
          "description": "The version of R to be installed",
          "type": "string"
        },
        "userManaged": {
          "description": "Indicates whether the environment is managed by user or by AzureML.",
          "type": "boolean"
        },
        "rscriptPath": {
          "description": "The Rscript path to use if an environment build is not required.\r\nThe path specified gets used to call the user script.",
          "type": "string"
        },
        "snapshotDate": {
          "description": "Date of MRAN snapshot to use in YYYY-MM-DD format, e.g. \"2019-04-17\"",
          "type": "string"
        },
        "cranPackages": {
          "description": "The CRAN packages to use.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/RCranPackage"
          }
        },
        "gitHubPackages": {
          "description": "The packages directly from GitHub.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/RGitHubPackage"
          }
        },
        "customUrlPackages": {
          "description": "The packages from custom urls.",
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "bioConductorPackages": {
          "description": "The packages from Bioconductor.",
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      }
    },
    "RSectionResponse": {
      "type": "object",
      "properties": {
        "rVersion": {
          "description": "The version of R to be installed",
          "type": "string"
        },
        "userManaged": {
          "description": "Indicates whether the environment is managed by user or by AzureML.",
          "type": "boolean"
        },
        "rscriptPath": {
          "description": "The Rscript path to use if an environment build is not required.\r\nThe path specified gets used to call the user script.",
          "type": "string"
        },
        "snapshotDate": {
          "description": "Date of MRAN snapshot to use in YYYY-MM-DD format, e.g. \"2019-04-17\"",
          "type": "string"
        },
        "cranPackages": {
          "description": "The CRAN packages to use.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/RCranPackage"
          }
        },
        "gitHubPackages": {
          "description": "The packages directly from GitHub.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/RGitHubPackageResponse"
          }
        },
        "customUrlPackages": {
          "description": "The packages from custom urls.",
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "bioConductorPackages": {
          "description": "The packages from Bioconductor.",
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      }
    },
    "DatasetReference": {
      "description": "The dataset reference object.",
      "type": "object",
      "properties": {
        "name": {
          "description": "The name of the dataset reference.",
          "type": "string"
        },
        "id": {
          "description": "The id of the dataset reference.",
          "type": "string"
        }
      }
    },
    "AKSVariantResponse": {
      "description": "The response for an AKS variant.",
      "type": "object",
      "allOf": [
        {
          "$ref": "#/definitions/ServiceResponseBase"
        },
        {
          "type": "object",
          "properties": {
            "isDefault": {
              "description": "Is this the default variant.",
              "type": "boolean"
            },
            "trafficPercentile": {
              "format": "float",
              "description": "The amount of traffic variant receives.",
              "type": "number",
              "example": 100
            },
            "type": {
              "description": "The type of the variant.",
              "enum": [
                "Control",
                "Treatment"
              ],
              "type": "string",
              "example": "Control",
              "x-ms-enum": {
                "name": "VariantType",
                "modelAsString": true
              }
            }
          }
        }
      ],
      "x-ms-discriminator-value": "Custom"
    },
    "AutoScaler": {
      "description": "The Auto Scaler properties.",
      "type": "object",
      "properties": {
        "autoscaleEnabled": {
          "description": "Option to enable/disable auto scaling.",
          "type": "boolean"
        },
        "minReplicas": {
          "format": "int32",
          "description": "The minimum number of replicas to scale down to.",
          "type": "integer",
          "example": 1
        },
        "maxReplicas": {
          "format": "int32",
          "description": "The maximum number of replicas in the cluster.",
          "type": "integer",
          "example": 3
        },
        "targetUtilization": {
          "format": "int32",
          "description": "The target utilization percentage to use for determining whether to scale the cluster.",
          "type": "integer",
          "example": 70
        },
        "refreshPeriodInSeconds": {
          "format": "int32",
          "description": "The amount of seconds to wait between auto scale updates.",
          "type": "integer",
          "example": 120
        }
      }
    },
    "AKSReplicaStatus": {
      "type": "object",
      "properties": {
        "desiredReplicas": {
          "format": "int32",
          "description": "The desired number of replicas.",
          "type": "integer",
          "example": 2
        },
        "updatedReplicas": {
          "format": "int32",
          "description": "The number of updated replicas.",
          "type": "integer",
          "example": 1
        },
        "availableReplicas": {
          "format": "int32",
          "description": "The number of available replicas.",
          "type": "integer",
          "example": 1
        },
        "error": {
          "description": "The error details.",
          "allOf": [
            {
              "$ref": "#/definitions/ErrorResponse"
            }
          ]
        }
      }
    },
    "LivenessProbeRequirements": {
      "description": "The liveness probe requirements.",
      "type": "object",
      "properties": {
        "failureThreshold": {
          "format": "int32",
          "description": "The number of failures to allow before returning an unhealthy status.",
          "type": "integer"
        },
        "successThreshold": {
          "format": "int32",
          "description": "The number of successful probes before returning a healthy status.",
          "type": "integer"
        },
        "timeoutSeconds": {
          "format": "int32",
          "description": "The probe timeout in seconds.",
          "type": "integer"
        },
        "periodSeconds": {
          "format": "int32",
          "description": "The length of time between probes in seconds.",
          "type": "integer"
        },
        "initialDelaySeconds": {
          "format": "int32",
          "description": "The delay before the first probe in seconds.",
          "type": "integer"
        }
      }
    },
    "AKSServiceResponse": {
      "description": "The response for an AKS service.",
      "type": "object",
      "allOf": [
        {
          "$ref": "#/definitions/AKSVariantResponse"
        },
        {
          "type": "object",
          "properties": {
            "models": {
              "description": "The list of models.",
              "type": "array",
              "items": {
                "$ref": "#/definitions/Model"
              }
            },
            "containerResourceRequirements": {
              "description": "The container resource requirements.",
              "$ref": "#/definitions/ContainerResourceRequirements"
            },
            "maxConcurrentRequestsPerContainer": {
              "format": "int32",
              "description": "The maximum number of concurrent requests per container.",
              "type": "integer",
              "example": 100
            },
            "maxQueueWaitMs": {
              "format": "int32",
              "description": "Maximum time a request will wait in the queue (in milliseconds). After this time, the service will return 503 (Service Unavailable)",
              "type": "integer",
              "example": 250
            },
            "computeName": {
              "description": "The name of the compute resource.",
              "type": "string"
            },
            "namespace": {
              "description": "The Kubernetes namespace of the deployment.",
              "type": "string",
              "example": "default"
            },
            "numReplicas": {
              "format": "int32",
              "description": "The number of replicas on the cluster.",
              "type": "integer",
              "example": 1
            },
            "dataCollection": {
              "description": "Details of the data collection options specified.",
              "allOf": [
                {
                  "$ref": "#/definitions/ModelDataCollection"
                }
              ]
            },
            "appInsightsEnabled": {
              "description": "Whether or not Application Insights is enabled.",
              "type": "boolean"
            },
            "autoScaler": {
              "description": "The auto scaler properties.",
              "allOf": [
                {
                  "$ref": "#/definitions/AutoScaler"
                }
              ]
            },
            "scoringUri": {
              "description": "The Uri for sending scoring requests.",
              "type": "string",
              "readOnly": true
            },
            "deploymentStatus": {
              "description": "The deployment status.",
              "readOnly": true,
              "allOf": [
                {
                  "$ref": "#/definitions/AKSReplicaStatus"
                }
              ]
            },
            "scoringTimeoutMs": {
              "format": "int32",
              "description": "The scoring timeout in milliseconds.",
              "type": "integer",
              "example": 100
            },
            "livenessProbeRequirements": {
              "description": "The liveness probe requirements.",
              "allOf": [
                {
                  "$ref": "#/definitions/LivenessProbeRequirements"
                }
              ]
            },
            "authEnabled": {
              "description": "Whether or not authentication is enabled.",
              "type": "boolean"
            },
            "aadAuthEnabled": {
              "description": "Whether or not AAD authentication is enabled.",
              "type": "boolean"
            },
            "swaggerUri": {
              "description": "The Uri for sending swagger requests.",
              "type": "string",
              "readOnly": true
            },
            "modelConfigMap": {
              "description": "Details on the models and configurations.",
              "type": "object",
              "additionalProperties": {
                "type": "object"
              },
              "readOnly": true
            },
            "environmentImageRequest": {
              "description": "The Environment, models and assets used for inferencing.",
              "allOf": [
                {
                  "$ref": "#/definitions/EnvironmentImageResponse"
                }
              ]
            }
          }
        }
      ],
      "x-ms-discriminator-value": "AKS"
    },
    "AuthKeys": {
      "type": "object",
      "properties": {
        "primaryKey": {
          "description": "The primary key.",
          "type": "string"
        },
        "secondaryKey": {
          "description": "The secondary key.",
          "type": "string"
        }
      }
    },
    "CreateServiceRequest": {
      "description": "The base class for creating a service.",
      "required": [
        "computeType"
      ],
      "type": "object",
      "properties": {
        "description": {
          "description": "The description of the service.",
          "type": "string"
        },
        "kvTags": {
          "description": "The service tag dictionary. Tags are mutable.",
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        },
        "properties": {
          "description": "The service properties dictionary. Properties are immutable.",
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        },
        "keys": {
          "description": "The authentication keys.",
          "allOf": [
            {
              "$ref": "#/definitions/AuthKeys"
            }
          ]
        },
        "computeType": {
          "description": "The compute environment type for the service.",
          "enum": [
            "ACI",
            "AKS"
          ],
          "type": "string",
          "example": "AKS",
          "x-ms-enum": {
            "name": "ComputeEnvironmentType",
            "modelAsString": true
          }
        },
        "environmentImageRequest": {
          "description": "The Environment, models and assets needed for inferencing.",
          "allOf": [
            {
              "$ref": "#/definitions/EnvironmentImageRequest"
            }
          ]
        },
        "location": {
          "description": "The name of the Azure location/region.",
          "type": "string"
        }
      },
      "discriminator": "computeType"
    },
    "ACIServiceCreateRequest": {
      "type": "object",
      "allOf": [
        {
          "$ref": "#/definitions/CreateServiceRequest"
        },
        {
          "type": "object",
          "properties": {
            "containerResourceRequirements": {
              "description": "The container resource requirements.",
              "$ref": "#/definitions/ContainerResourceRequirements"
            },
            "authEnabled": {
              "description": "Whether or not authentication is enabled on the service.",
              "default": false,
              "type": "boolean"
            },
            "sslEnabled": {
              "description": "Whether or not SSL is enabled.",
              "default": false,
              "type": "boolean"
            },
            "appInsightsEnabled": {
              "description": "Whether or not Application Insights is enabled.",
              "default": false,
              "type": "boolean"
            },
            "dataCollection": {
              "description": "Details of the data collection options specified.",
              "allOf": [
                {
                  "$ref": "#/definitions/ModelDataCollection"
                }
              ]
            },
            "sslCertificate": {
              "description": "The public SSL certificate in PEM format to use if SSL is enabled.",
              "type": "string"
            },
            "sslKey": {
              "description": "The public SSL key in PEM format for the certificate.",
              "type": "string"
            },
            "cname": {
              "description": "The CName for the service.",
              "type": "string"
            },
            "dnsNameLabel": {
              "description": "The Dns label for the service.",
              "type": "string"
            },
            "vnetConfiguration": {
              "description": "The virtual network configuration.",
              "allOf": [
                {
                  "$ref": "#/definitions/VnetConfiguration"
                }
              ]
            },
            "encryptionProperties": {
              "description": "The encryption properties.",
              "allOf": [
                {
                  "$ref": "#/definitions/EncryptionProperties"
                }
              ]
            }
          }
        }
      ],
      "x-ms-discriminator-value": "ACI"
    },
    "AKSServiceCreateRequest": {
      "description": "The request to create an AKS service.",
      "type": "object",
      "allOf": [
        {
          "$ref": "#/definitions/CreateEndpointVariantRequest"
        },
        {
          "type": "object",
          "properties": {
            "numReplicas": {
              "format": "int32",
              "description": "The number of replicas on the cluster.",
              "type": "integer",
              "example": 1
            },
            "dataCollection": {
              "description": "Details of the data collection options specified.",
              "allOf": [
                {
                  "$ref": "#/definitions/ModelDataCollection"
                }
              ]
            },
            "computeName": {
              "description": "The name of the compute resource.",
              "type": "string"
            },
            "appInsightsEnabled": {
              "description": "Whether or not Application Insights is enabled.",
              "type": "boolean"
            },
            "autoScaler": {
              "description": "The auto scaler properties.",
              "allOf": [
                {
                  "$ref": "#/definitions/AutoScaler"
                }
              ]
            },
            "containerResourceRequirements": {
              "description": "The container resource requirements.",
              "$ref": "#/definitions/ContainerResourceRequirements"
            },
            "maxConcurrentRequestsPerContainer": {
              "format": "int32",
              "description": "The maximum number of concurrent requests per container.",
              "type": "integer",
              "example": 100
            },
            "maxQueueWaitMs": {
              "format": "int32",
              "description": "Maximum time a request will wait in the queue (in milliseconds). After this time, the service will return 503 (Service Unavailable)",
              "type": "integer",
              "example": 250
            },
            "namespace": {
              "description": "Kubernetes namespace for the service.",
              "type": "string",
              "example": "default"
            },
            "scoringTimeoutMs": {
              "format": "int32",
              "description": "The scoring timeout in milliseconds.",
              "type": "integer",
              "example": 100
            },
            "authEnabled": {
              "description": "Whether or not authentication is enabled.",
              "type": "boolean"
            },
            "livenessProbeRequirements": {
              "description": "The liveness probe requirements.",
              "allOf": [
                {
                  "$ref": "#/definitions/LivenessProbeRequirements"
                }
              ]
            },
            "aadAuthEnabled": {
              "description": "Whether or not AAD authentication is enabled.",
              "type": "boolean"
            }
          }
        }
      ],
      "x-ms-discriminator-value": "AKS"
    },
    "CreateEndpointVariantRequest": {
      "description": "The Variant properties.",
      "type": "object",
      "allOf": [
        {
          "$ref": "#/definitions/CreateServiceRequest"
        },
        {
          "type": "object",
          "properties": {
            "isDefault": {
              "description": "Is this the default variant.",
              "type": "boolean"
            },
            "trafficPercentile": {
              "format": "float",
              "description": "The amount of traffic variant receives.",
              "type": "number",
              "example": 100
            },
            "type": {
              "description": "The type of the variant.",
              "enum": [
                "Control",
                "Treatment"
              ],
              "type": "string",
              "example": "Control",
              "x-ms-enum": {
                "name": "VariantType",
                "modelAsString": true
              }
            }
          }
        }
      ],
      "x-ms-discriminator-value": "Custom"
    },
    "DatasetCreateRequest": {
      "description": "The request for creating dataset.",
      "type": "object",
      "properties": {
        "skipValidation": {
          "description": "Skip validation that ensures data can be loaded from the dataset before registration.",
          "default": false,
          "type": "boolean"
        },
        "datasetType": {
          "description": "Specifies dataset type.",
          "type": "string",
          "enum": [
            "tabular",
            "file"
          ],
          "x-ms-enum": {
            "name": "DatasetType",
            "modelAsString": true
          }
        },
        "parameters": {
          "type": "object",
          "properties": {
            "header": {
              "description": "Header type.",
              "type": "string",
              "enum": [
                "all_files_have_same_headers",
                "only_first_file_has_headers",
                "no_headers",
                "combine_all_files_headers"
              ],
              "x-ms-enum": {
                "name": "Header",
                "modelAsString": true
              }
            },
            "includePath": {
              "description": "Boolean to keep path information as column in the dataset. Defaults to False. This is useful when reading multiple files, and want to know which file a particular record originated from, or to keep useful information in file path.",
              "default": false,
              "type": "boolean"
            },
            "partitionFormat": {
              "description": "The partition information of each path will be extracted into columns based on the specified format. Format part '{column_name}' creates string column, and '{column_name:yyyy/MM/dd/HH/mm/ss}' creates datetime column, where 'yyyy', 'MM', 'dd', 'HH', 'mm' and 'ss' are used to extract year, month, day, hour, minute and second for the datetime type. The format should start from the position of first partition key until the end of file path. For example, given the path '../USA/2019/01/01/data.parquet' where the partition is by country/region and time, partition_format='/{CountryOrRegion}/{PartitionDate:yyyy/MM/dd}/data.csv' creates a string column 'CountryOrRegion' with the value 'USA' and a datetime column 'PartitionDate' with the value '2019-01-01",
              "type": "string"
            },
            "path": {
              "type": "object",
              "properties": {
                "httpUrl": {
                  "description": "The Http URL.",
                  "type": "string"
                },
                "dataPath": {
                  "type": "object",
                  "properties": {
                    "datastoreName": {
                      "description": "The datastore name.",
                      "type": "string"
                    },
                    "relativePath": {
                      "description": "Path within the datastore.",
                      "type": "string"
                    }
                  }
                }
              }
            },
            "query": {
              "type": "object",
              "properties": {
                "datastoreName": {
                  "description": "The SQL/PostgreSQL/MySQL datastore name.",
                  "type": "string"
                },
                "query": {
                  "description": "SQL Quey.",
                  "type": "string"
                }
              }
            },
            "sourceType": {
              "description": "Data source type.",
              "type": "string",
              "enum": [
                "delimited_files",
                "json_lines_files",
                "parquet_files"
              ],
              "x-ms-enum": {
                "name": "SourceType",
                "modelAsString": true
              }
            },
            "separator": {
              "description": "The separator used to split columns for 'delimited_files' sourceType.",
              "type": "string"
            }
          }
        },
        "registration": {
          "type": "object",
          "properties": {
            "description": {
              "description": "The description for the dataset.",
              "type": "string"
            },
            "name": {
              "description": "The name of the dataset.",
              "type": "string"
            },
            "tags": {
              "description": "Tags associated with the dataset.",
              "type": "object",
              "additionalProperties": {
                "type": "string"
              }
            }
          }
        },
        "timeSeries": {
          "type": "object",
          "properties": {
            "fineGrainTimestamp": {
              "description": " Column name to be used as FineGrainTimestamp",
              "type": "string"
            },
            "coarseGrainTimestamp": {
              "description": "Column name to be used as CoarseGrainTimestamp. Can only be used if 'fineGrainTimestamp' is specified and cannot be same as 'fineGrainTimestamp'.",
              "type": "string"
            }
          }
        }
      },
      "required": [
        "datasetType",
        "parameters",
        "registration"
      ]
    },
    "DatastoreCreateRequest": {
      "description": "The request for creating datastore.",
      "type": "object",
      "properties": {
        "name": {
          "description": "The name of the datastore.",
          "type": "string"
        },
        "description": {
          "description": "The description of the datastore.",
          "type": "string"
        },
        "skipValidation": {
          "description": "Skip validation that ensures data can be loaded from the dataset before registration.",
          "type": "boolean"
        },
        "includeSecret": {
          "description": "Include datastore secret in response.",
          "default": true,
          "type": "boolean"
        },
        "dataStoreType": {
          "description": "Specifies datastore type.",
          "type": "string",
          "enum": [
            "blob",
            "adls",
            "adls-gen2",
            "dbfs",
            "file",
            "mysqldb",
            "sqldb",
            "psqldb"
          ],
          "x-ms-enum": {
            "name": "DatastoreTypeArm",
            "modelAsString": true
          }
        },
        "accountName": {
          "description": "The name of the storage account.",
          "type": "string"
        },
        "shareName": {
          "description": "The name of the file share.",
          "type": "string"
        },
        "containerName": {
          "description": "The name of the azure blob container.",
          "type": "string"
        },
        "accountKey": {
          "description": "Account Key of storage account.",
          "type": "string"
        },
        "endpoint": {
          "description": "The endpoint of the server.",
          "type": "string"
        },
        "protocol": {
          "description": "The protocol to be used",
          "type": "string"
        },
        "sasToken": {
          "description": "Sas Token of storage account.",
          "type": "string"
        },
        "clientId": {
          "description": "The service principal's client/application ID.",
          "type": "string"
        },
        "clientSecret": {
          "description": "The service principal's secret.",
          "type": "string"
        },
        "storeName": {
          "description": "The ADLS store name.",
          "type": "string"
        },
        "tenantId": {
          "description": "The service principal Tenant ID.",
          "type": "string"
        },
        "authorityUrl": {
          "description": "Authority url used to authenticate the user.",
          "type": "string"
        },
        "resourceUrl": {
          "description": "Determines what operations will be performed.",
          "type": "string"
        },
        "storageAccountSubscriptionId": {
          "description": "The subscription ID of the storage account. Defaults to selected subscription",
          "type": "string"
        },
        "storageAccountResourceGroup": {
          "description": "The resource group of the storage account. Defaults to selected resource group",
          "type": "string"
        },
        "adlsSubscriptionId": {
          "description": "The ID of the subscription the ADLS store belongs to. Defaults to selected subscription.",
          "type": "string"
        },
        "adlsResourceGroup": {
          "description": "The resource group the ADLS store belongs to. Defaults to selected resource group.",
          "type": "string"
        },
        "fileSystem": {
          "description": "The file system name of the ADLS Gen2.",
          "type": "string"
        },
        "databaseName": {
          "description": "The database name.",
          "type": "string"
        },
        "password": {
          "description": "The password.",
          "type": "string"
        },
        "serverName": {
          "description": "The SQL/MySQL/PostgreSQL server name",
          "type": "string"
        },
        "userId": {
          "description": "The user ID.",
          "type": "string"
        },
        "port": {
          "description": "The port number.",
          "type": "string"
        },
        "enforceSSL": {
          "description": "This sets the ssl value of the server. Defaults to true if not set.",
          "default": true,
          "type": "boolean"
        },
        "userName": {
          "description": "The username of the database user.",
          "type": "string"
        },
        "workspaceSystemAssignedIdentity": {
          "description": "If set to true, datastore support data access authenticated with Workspace MSI.",
          "type": "boolean"
        }
      },
      "required": [
        "dataStoreType"
      ]
    }
  }
}