purviewdatamap.json

{
  "swagger": "2.0",
  "info": {
    "title": "Azure Analytics Purview Data Map",
    "version": "2023-09-01",
    "description": "Purview Data Map Service is a fully managed cloud service whose users can\ndiscover the data sources they need and understand the data sources they find.\nAt the same time, Data Map helps organizations get more value from their\nexisting investments. This spec defines REST API of Purview Data Map Service.",
    "x-typespec-generated": [
      {
        "emitter": "@azure-tools/typespec-autorest"
      }
    ]
  },
  "schemes": [
    "https"
  ],
  "x-ms-parameterized-host": {
    "hostTemplate": "{endpoint}/datamap/api",
    "useSchemePrefix": false,
    "parameters": [
      {
        "name": "endpoint",
        "in": "path",
        "required": true,
        "type": "string"
      }
    ]
  },
  "produces": [
    "application/json"
  ],
  "consumes": [
    "application/json"
  ],
  "security": [
    {
      "OAuth2Auth": [
        "https://purview.azure.net/.default"
      ]
    }
  ],
  "securityDefinitions": {
    "OAuth2Auth": {
      "type": "oauth2",
      "flow": "implicit",
      "authorizationUrl": "https://login.microsoftonline.com/common/oauth2/authorize",
      "scopes": {
        "https://purview.azure.net/.default": ""
      }
    }
  },
  "tags": [],
  "paths": {
    "/atlas/v2/entity": {
      "post": {
        "operationId": "Entity_CreateOrUpdate",
        "description": "Create or update an entity.\nExisting entity is matched using its unique guid if\nsupplied or by its unique attributes eg: qualifiedName.\nMap and array of\ncollections are not well supported. E.g., array<array<int>>, array<map<string,\nint>>.\nFor each contact type, the maximum number of contacts is 20.",
        "parameters": [
          {
            "$ref": "#/parameters/AtlasApiVersionParameter"
          },
          {
            "name": "businessAttributeUpdateBehavior",
            "in": "query",
            "description": "Used to define the update behavior for business attributes when updating\nentities.",
            "required": false,
            "type": "string",
            "enum": [
              "ignore",
              "replace",
              "merge"
            ],
            "x-ms-enum": {
              "name": "BusinessAttributeUpdateBehavior",
              "modelAsString": true,
              "values": [
                {
                  "name": "Ignore",
                  "value": "ignore",
                  "description": "Ignore the business attribute payload for update."
                },
                {
                  "name": "Replace",
                  "value": "replace",
                  "description": "Replace all the business attributes using the payload."
                },
                {
                  "name": "Merge",
                  "value": "merge",
                  "description": "Merge the business attributes. Business attributes will not be updated if not provided."
                }
              ]
            }
          },
          {
            "name": "collectionId",
            "in": "query",
            "description": "The collection where entities will be moved to. Only specify a value if you\nneed to move an entity to another collection.",
            "required": false,
            "type": "string"
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AtlasEntityWithExtInfo"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/EntityMutationResult"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_AddCustomAttribute": {
            "$ref": "./examples/Entity_AddCustomAttribute.json"
          },
          "Entity_Create": {
            "$ref": "./examples/Entity_Create.json"
          },
          "Entity_Update": {
            "$ref": "./examples/Entity_Update.json"
          }
        }
      }
    },
    "/atlas/v2/entity/bulk": {
      "get": {
        "operationId": "Entity_ListByGuids",
        "description": "List entities in bulk identified by its GUIDs.",
        "parameters": [
          {
            "$ref": "#/parameters/AtlasApiVersionParameter"
          },
          {
            "name": "guid",
            "in": "query",
            "description": "An array of GUIDs of entities to list.",
            "required": true,
            "type": "array",
            "items": {
              "type": "string"
            },
            "collectionFormat": "multi"
          },
          {
            "name": "minExtInfo",
            "in": "query",
            "description": "Whether to return minimal information for referred entities.",
            "required": false,
            "type": "boolean"
          },
          {
            "name": "ignoreRelationships",
            "in": "query",
            "description": "Whether to ignore relationship attributes.",
            "required": false,
            "type": "boolean"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasEntitiesWithExtInfo"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_ListByGuids": {
            "$ref": "./examples/Entity_ListByGuids.json"
          }
        }
      },
      "post": {
        "operationId": "Entity_BulkCreateOrUpdate",
        "description": "Create or update entities in bulk.\nExisting entity is matched using its unique\nguid if supplied or by its unique attributes eg: qualifiedName.\nMap and array\nof collections are not well supported. E.g., array<array<int>>,\narray<map<string, int>>.\nFor each contact type, the maximum number of contacts\nis 20.",
        "parameters": [
          {
            "$ref": "#/parameters/AtlasApiVersionParameter"
          },
          {
            "name": "collectionId",
            "in": "query",
            "description": "The collection where entities will be moved to. Only specify a value if you\nneed to move an entity to another collection.",
            "required": false,
            "type": "string"
          },
          {
            "name": "businessAttributeUpdateBehavior",
            "in": "query",
            "description": "Used to define the update behavior for business attributes when updating\nentities.",
            "required": false,
            "type": "string",
            "enum": [
              "ignore",
              "replace",
              "merge"
            ],
            "x-ms-enum": {
              "name": "BusinessAttributeUpdateBehavior",
              "modelAsString": true,
              "values": [
                {
                  "name": "Ignore",
                  "value": "ignore",
                  "description": "Ignore the business attribute payload for update."
                },
                {
                  "name": "Replace",
                  "value": "replace",
                  "description": "Replace all the business attributes using the payload."
                },
                {
                  "name": "Merge",
                  "value": "merge",
                  "description": "Merge the business attributes. Business attributes will not be updated if not provided."
                }
              ]
            }
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AtlasEntitiesWithExtInfo"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/EntityMutationResult"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_BulkCreateOrUpdate": {
            "$ref": "./examples/Entity_BulkCreateOrUpdate.json"
          }
        }
      },
      "delete": {
        "operationId": "Entity_BulkDelete",
        "description": "Delete a list of entities in bulk identified by their GUIDs or unique\nattributes.",
        "parameters": [
          {
            "name": "guid",
            "in": "query",
            "description": "An array of GUIDs of entities to delete.",
            "required": true,
            "type": "array",
            "items": {
              "type": "string"
            },
            "collectionFormat": "multi"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/EntityMutationResult"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_BulkDelete": {
            "$ref": "./examples/Entity_BulkDelete.json"
          }
        }
      }
    },
    "/atlas/v2/entity/bulk/classification": {
      "post": {
        "operationId": "Entity_AddClassification",
        "description": "Associate a classification to multiple entities in bulk.",
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/ClassificationAssociateOptions"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_AddClassificationToEntityByGuids": {
            "$ref": "./examples/Entity_AddClassificationToEntityByGuids.json"
          }
        }
      }
    },
    "/atlas/v2/entity/bulk/setClassifications": {
      "post": {
        "operationId": "Entity_BulkSetClassifications",
        "description": "Set classifications on entities in bulk.",
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AtlasEntityHeaders"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_BulkSetClassifications": {
            "$ref": "./examples/Entity_BulkSetClassifications.json"
          }
        }
      }
    },
    "/atlas/v2/entity/bulk/uniqueAttribute/type/{typeName}": {
      "get": {
        "operationId": "Entity_ListByUniqueAttributes",
        "description": "Bulk API to retrieve list of entities identified by its unique attributes.\nIn\naddition to the typeName path parameter, attribute key-value pair(s) can be\nprovided in the following\nformat\n\ntypeName=\\<typeName>&attr_1:\\<attrName>=\\<attrValue>&attr_2:\\<attrName>=\\<attrValue>&attr_3:\\<attrName>=\\<attrValue>\n\nNOTE:\nThe attrName should be an unique attribute for the given entity-type.\nThe REST\nrequest would look something like this\n\nGET\n/v2/entity/bulk/uniqueAttribute/type/hive_db?attr_1:qualifiedName=db1@cl1&attr_2:qualifiedName=db2@cl1\n\nNote:\nat least one unique attribute must be provided.",
        "parameters": [
          {
            "name": "typeName",
            "in": "path",
            "description": "The name of the type.",
            "required": true,
            "type": "string"
          },
          {
            "name": "minExtInfo",
            "in": "query",
            "description": "Whether to return minimal information for referred entities.",
            "required": false,
            "type": "boolean"
          },
          {
            "name": "ignoreRelationships",
            "in": "query",
            "description": "Whether to ignore relationship attributes.",
            "required": false,
            "type": "boolean"
          },
          {
            "name": "attr_N:qualifiedName",
            "in": "query",
            "description": "Qualified name of an entity. E.g. to find 2 entities you can set\nattrs_1:qualifiedName=db1@cl1&attrs_2:qualifiedName=db2@cl1. (This is only an\nexample. qualifiedName can be changed to other unique attributes)",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasEntitiesWithExtInfo"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_ListByUniqueAttributes": {
            "$ref": "./examples/Entity_ListByUniqueAttributes.json"
          }
        }
      }
    },
    "/atlas/v2/entity/businessmetadata/import": {
      "post": {
        "operationId": "Entity_ImportBusinessMetadata",
        "description": "Upload the file for creating Business Metadata in BULK",
        "consumes": [
          "multipart/form-data"
        ],
        "parameters": [
          {
            "name": "file",
            "in": "formData",
            "description": "InputStream of file",
            "required": true,
            "type": "file"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/BulkImportResult"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_ImportBusinessMetadata": {
            "$ref": "./examples/Entity_ImportBusinessMetadata.json"
          }
        }
      }
    },
    "/atlas/v2/entity/businessmetadata/import/template": {
      "get": {
        "operationId": "Entity_GetSampleBusinessMetadataTemplate",
        "description": "Get the sample Template for uploading/creating bulk BusinessMetaData",
        "produces": [
          "application/octet-stream",
          "application/json"
        ],
        "parameters": [],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "type": "file"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_GetSampleBusinessMetadataTemplate": {
            "$ref": "./examples/Entity_GetSampleBusinessMetadataTemplate.json"
          }
        }
      }
    },
    "/atlas/v2/entity/guid/{guid}": {
      "get": {
        "operationId": "Entity_Get",
        "description": "Get complete definition of an entity given its GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          },
          {
            "name": "minExtInfo",
            "in": "query",
            "description": "Whether to return minimal information for referred entities.",
            "required": false,
            "type": "boolean"
          },
          {
            "name": "ignoreRelationships",
            "in": "query",
            "description": "Whether to ignore relationship attributes.",
            "required": false,
            "type": "boolean"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasEntityWithExtInfo"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_Get": {
            "$ref": "./examples/Entity_Get.json"
          }
        }
      },
      "put": {
        "operationId": "Entity_PartialUpdateAttributeByGuid",
        "description": "Update entity partially - create or update entity attribute identified by its\nGUID.\nSupports only primitive attribute type and entity references.\nIt does not support updating complex types like arrays, and maps.\nNull updates are not possible.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          },
          {
            "name": "name",
            "in": "query",
            "description": "The name of the attribute.",
            "required": true,
            "type": "string"
          },
          {
            "name": "body",
            "in": "body",
            "description": "The value of the attribute.",
            "required": true,
            "schema": {}
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/EntityMutationResult"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_PartialUpdateAttributeByGuid": {
            "$ref": "./examples/Entity_PartialUpdateAttributeByGuid.json"
          }
        }
      },
      "delete": {
        "operationId": "Entity_Delete",
        "description": "Delete an entity identified by its GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/EntityMutationResult"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_Delete": {
            "$ref": "./examples/Entity_Delete.json"
          }
        }
      }
    },
    "/atlas/v2/entity/guid/{guid}/businessmetadata": {
      "post": {
        "operationId": "Entity_AddOrUpdateBusinessMetadata",
        "description": "Add business metadata to an entity.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          },
          {
            "name": "isOverwrite",
            "in": "query",
            "description": "Whether to overwrite the existing business metadata on the entity or not,\ndefault is false.",
            "required": false,
            "type": "boolean",
            "x-ms-client-name": "overwrite"
          },
          {
            "name": "body",
            "in": "body",
            "description": "BusinessMetadata payload",
            "required": true,
            "schema": {
              "type": "object",
              "additionalProperties": {
                "additionalProperties": {},
                "type": "object"
              }
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_AddOrUpdate_BusinessMetadata": {
            "$ref": "./examples/Entity_AddOrUpdate_BusinessMetadata.json"
          }
        }
      },
      "delete": {
        "operationId": "Entity_RemoveBusinessMetadata",
        "description": "Remove business metadata from an entity.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          },
          {
            "name": "body",
            "in": "body",
            "description": "Business metadata payload",
            "required": true,
            "schema": {
              "type": "object",
              "additionalProperties": {
                "additionalProperties": {},
                "type": "object"
              }
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_RemoveBusinessMetadata": {
            "$ref": "./examples/Entity_RemoveBusinessMetadata.json"
          }
        }
      }
    },
    "/atlas/v2/entity/guid/{guid}/businessmetadata/{businessMetadataName}": {
      "post": {
        "operationId": "Entity_AddOrUpdateBusinessMetadataAttributes",
        "description": "Add or update business metadata attributes.",
        "parameters": [
          {
            "name": "businessMetadataName",
            "in": "path",
            "description": "BusinessMetadata name",
            "required": true,
            "type": "string"
          },
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          },
          {
            "name": "body",
            "in": "body",
            "description": "Business metadata attribute payload",
            "required": true,
            "schema": {
              "type": "object",
              "additionalProperties": {}
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_AddOrUpdate_BusinessAttribute": {
            "$ref": "./examples/Entity_AddOrUpdate_BusinessAttribute.json"
          }
        }
      },
      "delete": {
        "operationId": "Entity_RemoveBusinessMetadataAttributes",
        "description": "Delete business metadata attributes from an entity.",
        "parameters": [
          {
            "name": "businessMetadataName",
            "in": "path",
            "description": "BusinessMetadata name",
            "required": true,
            "type": "string"
          },
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          },
          {
            "name": "body",
            "in": "body",
            "description": "Business metadata attribute payload",
            "required": true,
            "schema": {
              "type": "object",
              "additionalProperties": {}
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_RemoveBusinessAttribute": {
            "$ref": "./examples/Entity_RemoveBusinessAttribute.json"
          }
        }
      }
    },
    "/atlas/v2/entity/guid/{guid}/classification/{classificationName}": {
      "get": {
        "operationId": "Entity_GetClassification",
        "description": "Get classification for a given entity represented by a GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          },
          {
            "name": "classificationName",
            "in": "path",
            "description": "The name of the classification.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasClassification"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_GetClassification": {
            "$ref": "./examples/Entity_GetClassification.json"
          }
        }
      },
      "delete": {
        "operationId": "Entity_RemoveClassification",
        "description": "Delete a given classification from an existing entity represented by a GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          },
          {
            "name": "classificationName",
            "in": "path",
            "description": "The name of the classification.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_RemoveClassification": {
            "$ref": "./examples/Entity_RemoveClassification.json"
          }
        }
      }
    },
    "/atlas/v2/entity/guid/{guid}/classifications": {
      "get": {
        "operationId": "Entity_GetClassifications",
        "description": "List classifications for a given entity represented by a GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasClassifications"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_GetClassifications": {
            "$ref": "./examples/Entity_GetClassifications.json"
          }
        }
      },
      "put": {
        "operationId": "Entity_UpdateClassifications",
        "description": "Update classifications to an existing entity represented by a guid.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          },
          {
            "name": "body",
            "in": "body",
            "description": "An array of classifications to be updated.",
            "required": true,
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasClassification"
              },
              "x-ms-identifiers": []
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_UpdateClassifications": {
            "$ref": "./examples/Entity_UpdateClassifications.json"
          }
        }
      },
      "post": {
        "operationId": "Entity_AddClassifications",
        "description": "Add classifications to an existing entity represented by a GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          },
          {
            "name": "body",
            "in": "body",
            "description": "An array of classifications to be added.",
            "required": true,
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasClassification"
              },
              "x-ms-identifiers": []
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_AddClassifications": {
            "$ref": "./examples/Entity_AddClassifications.json"
          }
        }
      }
    },
    "/atlas/v2/entity/guid/{guid}/header": {
      "get": {
        "operationId": "Entity_GetHeader",
        "description": "Get entity header given its GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasEntityHeader"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_GetHeader": {
            "$ref": "./examples/Entity_GetHeader.json"
          }
        }
      }
    },
    "/atlas/v2/entity/guid/{guid}/labels": {
      "put": {
        "operationId": "Entity_AddLabel",
        "description": "Add given labels to a given entity.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          },
          {
            "name": "body",
            "in": "body",
            "description": "set of labels to be added",
            "required": false,
            "schema": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_AddLabel": {
            "$ref": "./examples/Entity_AddLabel.json"
          }
        }
      },
      "post": {
        "operationId": "Entity_SetLabels",
        "description": "Set labels to a given entity.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          },
          {
            "name": "body",
            "in": "body",
            "description": "set of labels to be set to the entity",
            "required": false,
            "schema": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_SetLabels": {
            "$ref": "./examples/Entity_SetLabels.json"
          }
        }
      },
      "delete": {
        "operationId": "Entity_RemoveLabels",
        "description": "Delete given labels to a given entity.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          },
          {
            "name": "body",
            "in": "body",
            "description": "set of labels to be deleted",
            "required": false,
            "schema": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_RemoveLabels": {
            "$ref": "./examples/Entity_RemoveLabels.json"
          }
        }
      }
    },
    "/atlas/v2/entity/uniqueAttribute/type/{typeName}": {
      "get": {
        "operationId": "Entity_GetByUniqueAttributes",
        "description": "Get complete definition of an entity given its type and unique attribute.\n\nIn\naddition to the typeName path parameter, attribute key-value pair(s) can be\nprovided in the following format:\nattr:\\<attrName>=<attrValue>.\n\nNOTE: The\nattrName and attrValue should be unique across entities, eg.\nqualifiedName.\n\nThe REST request would look something like this:\nGET\n/v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue.",
        "parameters": [
          {
            "name": "typeName",
            "in": "path",
            "description": "The name of the type.",
            "required": true,
            "type": "string"
          },
          {
            "name": "minExtInfo",
            "in": "query",
            "description": "Whether to return minimal information for referred entities.",
            "required": false,
            "type": "boolean"
          },
          {
            "name": "ignoreRelationships",
            "in": "query",
            "description": "Whether to ignore relationship attributes.",
            "required": false,
            "type": "boolean"
          },
          {
            "name": "attr:qualifiedName",
            "in": "query",
            "description": "The qualified name of the entity. (This is only an example. qualifiedName can\nbe changed to other unique attributes)",
            "required": false,
            "type": "string",
            "x-ms-client-name": "attribute"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasEntityWithExtInfo"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_GetByUniqueAttributes": {
            "$ref": "./examples/Entity_GetByUniqueAttributes.json"
          }
        }
      },
      "put": {
        "operationId": "Entity_PartialUpdateByUniqueAttributes",
        "description": "Update entity partially - Allow a subset of attributes to be updated on an\nentity which is identified by its type and unique attribute eg:\nReferenceable.qualifiedName. Null updates are not possible.\n\nIn addition to the\ntypeName path parameter, attribute key-value pair(s) can be provided in the\nfollowing format:\n\nattr:<attrName>=<attrValue>.\nNOTE: The attrName and\nattrValue should be unique across entities, eg. qualifiedName.\n\nThe REST\nrequest would look something like this:\nPUT\n/v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue.",
        "parameters": [
          {
            "name": "typeName",
            "in": "path",
            "description": "The name of the type.",
            "required": true,
            "type": "string"
          },
          {
            "name": "attr:qualifiedName",
            "in": "query",
            "description": "The qualified name of the entity. (This is only an example. qualifiedName can\nbe changed to other unique attributes)",
            "required": false,
            "type": "string",
            "x-ms-client-name": "attribute"
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AtlasEntityWithExtInfo"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/EntityMutationResult"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_PartialUpdateByUniqueAttributes": {
            "$ref": "./examples/Entity_PartialUpdateByUniqueAttributes.json"
          }
        }
      },
      "delete": {
        "operationId": "Entity_DeleteByUniqueAttribute",
        "description": "Delete an entity identified by its type and unique attributes.\nIn addition to\nthe typeName path parameter, attribute key-value pair(s) can be provided in the\nfollowing format:\nattr:\\<attrName>=\\<attrValue>.\nNOTE: The attrName and\nattrValue should be unique across entities, eg. qualifiedName.\n\nThe REST\nrequest would look something like this:\nDELETE\n/v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue.",
        "parameters": [
          {
            "name": "typeName",
            "in": "path",
            "description": "The name of the type.",
            "required": true,
            "type": "string"
          },
          {
            "name": "attr:qualifiedName",
            "in": "query",
            "description": "The qualified name of the entity. (This is only an example. qualifiedName can\nbe changed to other unique attributes)",
            "required": false,
            "type": "string",
            "x-ms-client-name": "attribute"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/EntityMutationResult"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_DeleteByUniqueAttribute": {
            "$ref": "./examples/Entity_DeleteByUniqueAttribute.json"
          }
        }
      }
    },
    "/atlas/v2/entity/uniqueAttribute/type/{typeName}/classification/{classificationName}": {
      "delete": {
        "operationId": "Entity_RemoveClassificationByUniqueAttribute",
        "description": "Delete a given classification from an entity identified by its type and unique\nattributes.",
        "parameters": [
          {
            "name": "typeName",
            "in": "path",
            "description": "The name of the type.",
            "required": true,
            "type": "string"
          },
          {
            "name": "classificationName",
            "in": "path",
            "description": "The name of the classification.",
            "required": true,
            "type": "string"
          },
          {
            "name": "attr:qualifiedName",
            "in": "query",
            "description": "The qualified name of the entity. (This is only an example. qualifiedName can\nbe changed to other unique attributes)",
            "required": false,
            "type": "string",
            "x-ms-client-name": "attribute"
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_RemoveClassificationByUniqueAttribute": {
            "$ref": "./examples/Entity_RemoveClassificationByUniqueAttribute.json"
          }
        }
      }
    },
    "/atlas/v2/entity/uniqueAttribute/type/{typeName}/classifications": {
      "put": {
        "operationId": "Entity_UpdateClassificationsByUniqueAttribute",
        "description": "Update classification on an entity identified by its type and unique attributes.",
        "parameters": [
          {
            "name": "typeName",
            "in": "path",
            "description": "The name of the type.",
            "required": true,
            "type": "string"
          },
          {
            "name": "attr:qualifiedName",
            "in": "query",
            "description": "The qualified name of the entity. (This is only an example. qualifiedName can\nbe changed to other unique attributes)",
            "required": false,
            "type": "string",
            "x-ms-client-name": "attribute"
          },
          {
            "name": "body",
            "in": "body",
            "description": "An array of classification to be updated.",
            "required": true,
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasClassification"
              },
              "x-ms-identifiers": []
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_UpdateClassificationsByUniqueAttribute": {
            "$ref": "./examples/Entity_UpdateClassificationsByUniqueAttribute.json"
          }
        }
      },
      "post": {
        "operationId": "Entity_AddClassificationsByUniqueAttribute",
        "description": "Add classification to the entity identified by its type and unique attributes.",
        "parameters": [
          {
            "name": "typeName",
            "in": "path",
            "description": "The name of the type.",
            "required": true,
            "type": "string"
          },
          {
            "name": "attr:qualifiedName",
            "in": "query",
            "description": "The qualified name of the entity. (This is only an example. qualifiedName can\nbe changed to other unique attributes)",
            "required": false,
            "type": "string",
            "x-ms-client-name": "attribute"
          },
          {
            "name": "body",
            "in": "body",
            "description": "An array of classification to be added.",
            "required": true,
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasClassification"
              },
              "x-ms-identifiers": []
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_AddClassificationsByUniqueAttribute": {
            "$ref": "./examples/Entity_AddClassificationsByUniqueAttribute.json"
          }
        }
      }
    },
    "/atlas/v2/entity/uniqueAttribute/type/{typeName}/labels": {
      "put": {
        "operationId": "Entity_AddLabelsByUniqueAttribute",
        "description": "Add given labels to a given entity identified by its type and unique\nattributes.\n\nIf labels is null/empty, no labels will be added.\n\nIn addition to\nthe typeName path parameter, attribute key-value pair(s) can be provided in the\nfollowing format: attr:<attrName>=<attrValue>.\n\nNOTE: The attrName and\nattrValue should be unique across entities, eg. qualifiedName.\n\nThe REST\nrequest would look something like this: PUT\n/v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue.",
        "parameters": [
          {
            "name": "typeName",
            "in": "path",
            "description": "The name of the type.",
            "required": true,
            "type": "string"
          },
          {
            "name": "attr:qualifiedName",
            "in": "query",
            "description": "The qualified name of the entity. (This is only an example. qualifiedName can\nbe changed to other unique attributes)",
            "required": false,
            "type": "string",
            "x-ms-client-name": "attribute"
          },
          {
            "name": "body",
            "in": "body",
            "description": "set of labels to be added",
            "required": false,
            "schema": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_AddLabelsByUniqueAttribute": {
            "$ref": "./examples/Entity_AddLabelsByUniqueAttribute.json"
          }
        }
      },
      "post": {
        "operationId": "Entity_SetLabelsByUniqueAttribute",
        "description": "Set labels to a given entity identified by its type and unique attributes.\n\nIf\nlabels is null/empty, existing labels will all be removed.\n\nIn addition to the\ntypeName path parameter, attribute key-value pair(s) can be provided in the\nfollowing format: attr:<attrName>=<attrValue>.\n\nNOTE: The attrName and\nattrValue should be unique across entities, eg. qualifiedName.\n\nThe REST\nrequest would look something like this: POST\n/v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue.",
        "parameters": [
          {
            "name": "typeName",
            "in": "path",
            "description": "The name of the type.",
            "required": true,
            "type": "string"
          },
          {
            "name": "attr:qualifiedName",
            "in": "query",
            "description": "The qualified name of the entity. (This is only an example. qualifiedName can\nbe changed to other unique attributes)",
            "required": false,
            "type": "string",
            "x-ms-client-name": "attribute"
          },
          {
            "name": "body",
            "in": "body",
            "description": "set of labels to be set",
            "required": false,
            "schema": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_SetLabelsByUniqueAttribute": {
            "$ref": "./examples/Entity_SetLabelsByUniqueAttribute.json"
          }
        }
      },
      "delete": {
        "operationId": "Entity_RemoveLabelsByUniqueAttribute",
        "description": "Delete given labels to a given entity identified by its type and unique\nattribute.\n\nIf labels is null/empty, no labels will be removed.\n\nIf any labels\nin labels set are non-existing labels, they will be ignored, only existing\nlabels will be removed. In addition to the typeName path parameter, attribute\nkey-value pair(s) can be provided in the following format:\nattr:<attrName>=<attrValue>. NOTE: The attrName and attrValue should be unique\nacross entities, eg. qualifiedName. The REST request would look something like\nthis: DELETE\n/v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue.",
        "parameters": [
          {
            "name": "typeName",
            "in": "path",
            "description": "The name of the type.",
            "required": true,
            "type": "string"
          },
          {
            "name": "attr:qualifiedName",
            "in": "query",
            "description": "The qualified name of the entity. (This is only an example. qualifiedName can\nbe changed to other unique attributes)",
            "required": false,
            "type": "string",
            "x-ms-client-name": "attribute"
          },
          {
            "name": "body",
            "in": "body",
            "description": "set of labels to be deleted",
            "required": false,
            "schema": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_RemoveLabelsByUniqueAttribute": {
            "$ref": "./examples/Entity_RemoveLabelsByUniqueAttribute.json"
          }
        }
      }
    },
    "/atlas/v2/glossary": {
      "get": {
        "operationId": "Glossary_List",
        "description": "Get all glossaries. Recommend using limit/offset to get pagination result.\nRecommend using 'ignoreTermsAndCategories=true' and fetch terms/categories\nseparately using \n\n 'GET /datamap/api/atlas/v2/glossary/{glossaryId}/terms'\nand \n\n 'GET '/datamap/api/atlas/v2/glossary/{glossaryId}/categories'.",
        "parameters": [
          {
            "$ref": "#/parameters/AtlasApiVersionParameter"
          },
          {
            "name": "limit",
            "in": "query",
            "description": "The page size - by default there is no paging.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "offset",
            "in": "query",
            "description": "The offset for pagination purpose.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "sort",
            "in": "query",
            "description": "The sort order, ASC (default) or DESC.",
            "required": false,
            "type": "string"
          },
          {
            "name": "ignoreTermsAndCategories",
            "in": "query",
            "description": "Whether ignore terms and categories",
            "required": false,
            "type": "boolean"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasGlossary"
              },
              "x-ms-identifiers": []
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_List": {
            "$ref": "./examples/Glossary_List.json"
          }
        }
      },
      "post": {
        "operationId": "Glossary_Create",
        "description": "Create a glossary.",
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AtlasGlossary"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasGlossary"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_Create": {
            "$ref": "./examples/Glossary_Create.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/{glossaryId}": {
      "get": {
        "operationId": "Glossary_Get",
        "description": "Get a specific Glossary by its GUID.",
        "parameters": [
          {
            "name": "glossaryId",
            "in": "path",
            "description": "The globally unique identifier for glossary.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasGlossary"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_Get": {
            "$ref": "./examples/Glossary_Get.json"
          }
        }
      },
      "put": {
        "operationId": "Glossary_Update",
        "description": "Update the given glossary.",
        "parameters": [
          {
            "$ref": "#/parameters/AtlasApiVersionParameter"
          },
          {
            "name": "glossaryId",
            "in": "path",
            "description": "The globally unique identifier for glossary.",
            "required": true,
            "type": "string"
          },
          {
            "name": "ignoreTermsAndCategories",
            "in": "query",
            "description": "Whether ignore terms and categories",
            "required": false,
            "type": "boolean"
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AtlasGlossary"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasGlossary"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_Update": {
            "$ref": "./examples/Glossary_Update.json"
          }
        }
      },
      "delete": {
        "operationId": "Glossary_Delete",
        "description": "Delete a glossary. Will delete underlying terms/categories together. Recommend\nseparate delete terms and categories.",
        "parameters": [
          {
            "name": "glossaryId",
            "in": "path",
            "description": "The globally unique identifier for glossary.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_Delete": {
            "$ref": "./examples/Glossary_Delete.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/{glossaryId}/categories": {
      "get": {
        "operationId": "Glossary_ListCategories",
        "description": "Get the categories belonging to a specific glossary. Recommend using\nlimit/offset to get pagination result.",
        "parameters": [
          {
            "name": "glossaryId",
            "in": "path",
            "description": "The globally unique identifier for glossary.",
            "required": true,
            "type": "string"
          },
          {
            "name": "limit",
            "in": "query",
            "description": "The page size - by default there is no paging.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "offset",
            "in": "query",
            "description": "The offset for pagination purpose.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "sort",
            "in": "query",
            "description": "The sort order, ASC (default) or DESC.",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasGlossaryCategory"
              },
              "x-ms-identifiers": []
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_ListCategories": {
            "$ref": "./examples/Glossary_ListCategories.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/{glossaryId}/categories/headers": {
      "get": {
        "operationId": "Glossary_ListCategoriesHeaders",
        "description": "Get the category headers belonging to a specific glossary. Recommend using\nlimit/offset to get pagination result.",
        "parameters": [
          {
            "name": "glossaryId",
            "in": "path",
            "description": "The globally unique identifier for glossary.",
            "required": true,
            "type": "string"
          },
          {
            "name": "limit",
            "in": "query",
            "description": "The page size - by default there is no paging.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "offset",
            "in": "query",
            "description": "The offset for pagination purpose.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "sort",
            "in": "query",
            "description": "The sort order, ASC (default) or DESC.",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasRelatedCategoryHeader"
              },
              "x-ms-identifiers": []
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_ListCategoriesHeaders": {
            "$ref": "./examples/Glossary_ListCategoriesHeaders.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/{glossaryId}/detailed": {
      "get": {
        "operationId": "Glossary_GetDetailed",
        "description": "Get a specific glossary with detailed information. This API is not\nrecommend.\n\nRecommend to fetch terms/categories details separately using \n\nGET /datamap/api/atlas/v2/glossary/{glossaryId}/terms and \n\nGET /datamap/api/atlas/v2/glossary/{glossaryId}/categories.",
        "parameters": [
          {
            "$ref": "#/parameters/AtlasApiVersionParameter"
          },
          {
            "name": "glossaryId",
            "in": "path",
            "description": "The globally unique identifier for glossary.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasGlossaryExtInfo"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_GetDetailed": {
            "$ref": "./examples/Glossary_GetDetailed.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/{glossaryId}/partial": {
      "put": {
        "operationId": "Glossary_PartialUpdate",
        "description": "Update the glossary partially. Some properties such as qualifiedName are not\nallowed to be updated.\n\nSo far we only supports partial updating\nshortDescription, longDescription, language and usage for glossary. \n\nRecommend\nusing 'ignoreTermsAndCategories=true' to reduce response body size.",
        "parameters": [
          {
            "$ref": "#/parameters/AtlasApiVersionParameter"
          },
          {
            "name": "glossaryId",
            "in": "path",
            "description": "The globally unique identifier for glossary.",
            "required": true,
            "type": "string"
          },
          {
            "name": "ignoreTermsAndCategories",
            "in": "query",
            "description": "Whether ignore terms and categories",
            "required": false,
            "type": "boolean"
          },
          {
            "name": "body",
            "in": "body",
            "description": "A map containing keys as attribute names and values as corresponding attribute\nvalues.",
            "required": true,
            "schema": {
              "type": "object",
              "additionalProperties": {
                "type": "string"
              }
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasGlossary"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_PartialUpdate": {
            "$ref": "./examples/Glossary_PartialUpdate.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/{glossaryId}/terms": {
      "get": {
        "operationId": "Glossary_ListTerms",
        "description": "Get terms belonging to a specific glossary. Recommend using limit/offset to get\npagination result.",
        "parameters": [
          {
            "$ref": "#/parameters/AtlasApiVersionParameter"
          },
          {
            "name": "glossaryId",
            "in": "path",
            "description": "The globally unique identifier for glossary.",
            "required": true,
            "type": "string"
          },
          {
            "name": "limit",
            "in": "query",
            "description": "The page size - by default there is no paging.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "offset",
            "in": "query",
            "description": "The offset for pagination purpose.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "sort",
            "in": "query",
            "description": "The sort order, ASC (default) or DESC.",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasGlossaryTerm"
              },
              "x-ms-identifiers": []
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_ListTerms": {
            "$ref": "./examples/Glossary_ListTerms.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/{glossaryId}/terms/headers": {
      "get": {
        "operationId": "Glossary_ListTermHeaders",
        "description": "Get term headers belonging to a specific glossary. Recommend using limit/offset\nto get pagination result.",
        "parameters": [
          {
            "name": "glossaryId",
            "in": "path",
            "description": "The globally unique identifier for glossary.",
            "required": true,
            "type": "string"
          },
          {
            "name": "limit",
            "in": "query",
            "description": "The page size - by default there is no paging.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "offset",
            "in": "query",
            "description": "The offset for pagination purpose.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "sort",
            "in": "query",
            "description": "The sort order, ASC (default) or DESC.",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasRelatedTermHeader"
              },
              "x-ms-identifiers": []
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_ListTermHeaders": {
            "$ref": "./examples/Glossary_ListTermHeaders.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/categories": {
      "post": {
        "operationId": "Glossary_CreateCategories",
        "description": "Create glossary category in bulk.",
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "description": "An array of glossary category definitions to be created.",
            "required": true,
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasGlossaryCategory"
              },
              "x-ms-identifiers": []
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasGlossaryCategory"
              },
              "x-ms-identifiers": []
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_CreateCategories": {
            "$ref": "./examples/Glossary_CreateCategories.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/category": {
      "post": {
        "operationId": "Glossary_CreateCategory",
        "description": "Create a glossary category.",
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AtlasGlossaryCategory"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasGlossaryCategory"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_CreateCategory": {
            "$ref": "./examples/Glossary_CreateCategory.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/category/{categoryId}": {
      "get": {
        "operationId": "Glossary_GetCategory",
        "description": "Get specific glossary category by its GUID.",
        "parameters": [
          {
            "name": "categoryId",
            "in": "path",
            "description": "The globally unique identifier of the category.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasGlossaryCategory"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_GetCategory": {
            "$ref": "./examples/Glossary_GetCategory.json"
          }
        }
      },
      "put": {
        "operationId": "Glossary_UpdateCategory",
        "description": "Update the given glossary category by its GUID.",
        "parameters": [
          {
            "name": "categoryId",
            "in": "path",
            "description": "The globally unique identifier of the category.",
            "required": true,
            "type": "string"
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AtlasGlossaryCategory"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasGlossaryCategory"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_UpdateCategory": {
            "$ref": "./examples/Glossary_UpdateCategory.json"
          }
        }
      },
      "delete": {
        "operationId": "Glossary_DeleteCategory",
        "description": "Delete a glossary category.",
        "parameters": [
          {
            "name": "categoryId",
            "in": "path",
            "description": "The globally unique identifier of the category.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_DeleteCategory": {
            "$ref": "./examples/Glossary_DeleteCategory.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/category/{categoryId}/partial": {
      "put": {
        "operationId": "Glossary_PartialUpdateCategory",
        "description": "Update the glossary category partially. So far we only supports partial\nupdating shortDescription and longDescription for category.",
        "parameters": [
          {
            "name": "categoryId",
            "in": "path",
            "description": "The globally unique identifier of the category.",
            "required": true,
            "type": "string"
          },
          {
            "name": "body",
            "in": "body",
            "description": "A map containing keys as attribute names and values as corresponding attribute\nvalues for partial update.",
            "required": true,
            "schema": {
              "type": "object",
              "additionalProperties": {
                "type": "string"
              }
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasGlossaryCategory"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_PartialUpdateCategory": {
            "$ref": "./examples/Glossary_PartialUpdateCategory.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/category/{categoryId}/related": {
      "get": {
        "operationId": "Glossary_ListRelatedCategories",
        "description": "Get all related categories (parent and children). Limit, offset, and sort\nparameters are currently not being enabled and won't work even they are passed.",
        "parameters": [
          {
            "name": "categoryId",
            "in": "path",
            "description": "The globally unique identifier of the category.",
            "required": true,
            "type": "string"
          },
          {
            "name": "limit",
            "in": "query",
            "description": "The page size - by default there is no paging.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "offset",
            "in": "query",
            "description": "The offset for pagination purpose.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "sort",
            "in": "query",
            "description": "The sort order, ASC (default) or DESC.",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "type": "object",
              "additionalProperties": {
                "items": {
                  "$ref": "#/definitions/AtlasRelatedCategoryHeader"
                },
                "type": "array",
                "x-ms-identifiers": []
              }
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_ListRelatedCategories": {
            "$ref": "./examples/Glossary_ListRelatedCategories.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/category/{categoryId}/terms": {
      "get": {
        "operationId": "Glossary_ListCategoryTerms",
        "description": "Get all terms associated with the specific category.",
        "parameters": [
          {
            "name": "categoryId",
            "in": "path",
            "description": "The globally unique identifier of the category.",
            "required": true,
            "type": "string"
          },
          {
            "name": "limit",
            "in": "query",
            "description": "The page size - by default there is no paging.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "offset",
            "in": "query",
            "description": "The offset for pagination purpose.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "sort",
            "in": "query",
            "description": "The sort order, ASC (default) or DESC.",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasRelatedTermHeader"
              },
              "x-ms-identifiers": []
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_ListCategoryTerms": {
            "$ref": "./examples/Glossary_ListCategoryTerms.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/term": {
      "post": {
        "operationId": "Glossary_CreateTerm",
        "description": "Create a glossary term.",
        "parameters": [
          {
            "name": "includeTermHierarchy",
            "in": "query",
            "description": "Whether include term hierarchy",
            "required": false,
            "type": "boolean"
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AtlasGlossaryTerm"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasGlossaryTerm"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_CreateTerm": {
            "$ref": "./examples/Glossary_CreateTerm.json"
          },
          "Glossary_CreateTermWithTemplate": {
            "$ref": "./examples/Glossary_CreateTermWithTemplate.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/term/{termId}": {
      "get": {
        "operationId": "Glossary_GetTerm",
        "description": "Get a specific glossary term by its GUID. ",
        "parameters": [
          {
            "$ref": "#/parameters/AtlasApiVersionParameter"
          },
          {
            "name": "termId",
            "in": "path",
            "description": "The globally unique identifier for glossary term.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasGlossaryTerm"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_GetTerm": {
            "$ref": "./examples/Glossary_GetTerm.json"
          },
          "Glossary_GetTermWithoutAssets": {
            "$ref": "./examples/Glossary_GetTermWithoutAssets.json"
          }
        }
      },
      "put": {
        "operationId": "Glossary_UpdateTerm",
        "description": "Update the given glossary term by its GUID.",
        "parameters": [
          {
            "$ref": "#/parameters/AtlasApiVersionParameter"
          },
          {
            "name": "termId",
            "in": "path",
            "description": "The globally unique identifier for glossary term.",
            "required": true,
            "type": "string"
          },
          {
            "name": "includeTermHierarchy",
            "in": "query",
            "description": "Whether include term hierarchy",
            "required": false,
            "type": "boolean"
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AtlasGlossaryTerm"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasGlossaryTerm"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_UpdateTerm": {
            "$ref": "./examples/Glossary_UpdateTerm.json"
          }
        }
      },
      "delete": {
        "operationId": "Glossary_DeleteTerm",
        "description": "Delete a glossary term.",
        "parameters": [
          {
            "name": "termId",
            "in": "path",
            "description": "The globally unique identifier for glossary term.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_DeleteTerm": {
            "$ref": "./examples/Glossary_DeleteTerm.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/term/{termId}/partial": {
      "put": {
        "operationId": "Glossary_PartialUpdateTerm",
        "description": "Update the glossary term partially. So far we only supports partial updating\nshortDescription, longDescription, abbreviation, usage and status for term.",
        "parameters": [
          {
            "$ref": "#/parameters/AtlasApiVersionParameter"
          },
          {
            "name": "termId",
            "in": "path",
            "description": "The globally unique identifier for glossary term.",
            "required": true,
            "type": "string"
          },
          {
            "name": "includeTermHierarchy",
            "in": "query",
            "description": "Whether include term hierarchy",
            "required": false,
            "type": "boolean"
          },
          {
            "name": "body",
            "in": "body",
            "description": "A map containing keys as attribute names and values as corresponding attribute\nvalues to be updated.",
            "required": true,
            "schema": {
              "type": "object",
              "additionalProperties": {
                "type": "string"
              }
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasGlossaryTerm"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_PartialUpdateTerm": {
            "$ref": "./examples/Glossary_PartialUpdateTerm.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/terms": {
      "post": {
        "operationId": "Glossary_CreateTerms",
        "description": "Create glossary terms in bulk.",
        "parameters": [
          {
            "$ref": "#/parameters/AtlasApiVersionParameter"
          },
          {
            "name": "includeTermHierarchy",
            "in": "query",
            "description": "Whether include term hierarchy",
            "required": false,
            "type": "boolean"
          },
          {
            "name": "body",
            "in": "body",
            "description": "An array of glossary term definitions to be created in bulk.",
            "required": true,
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasGlossaryTerm"
              },
              "x-ms-identifiers": []
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasGlossaryTerm"
              },
              "x-ms-identifiers": []
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_CreateTerms": {
            "$ref": "./examples/Glossary_CreateTerms.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/terms/{termId}/assignedEntities": {
      "get": {
        "operationId": "Glossary_ListEntitiesAssignedWithTerm",
        "description": "List all related objects assigned with the specified term. Recommend using\nlimit/offset to get pagination result.",
        "parameters": [
          {
            "name": "termId",
            "in": "path",
            "description": "The globally unique identifier for glossary term.",
            "required": true,
            "type": "string"
          },
          {
            "name": "limit",
            "in": "query",
            "description": "The page size - by default there is no paging.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "offset",
            "in": "query",
            "description": "The offset for pagination purpose.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "sort",
            "in": "query",
            "description": "The sort order, ASC (default) or DESC.",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasRelatedObjectId"
              },
              "x-ms-identifiers": []
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_ListEntitiesAssignedWithTerm": {
            "$ref": "./examples/Glossary_ListEntitiesAssignedWithTerm.json"
          }
        }
      },
      "post": {
        "operationId": "Glossary_AssignTermToEntities",
        "description": "Assign the given term to the provided list of related objects. Recommend using\nsmall batches with multiple API calls.\n\n[Entities Create Or Update\noperation](https://learn.microsoft.com/en-us/rest/api/purview/datamapdataplane/entity/bulk-create-or-update?tabs=HTTP)\nis an alternative to assign a term to multiple entities.",
        "parameters": [
          {
            "name": "termId",
            "in": "path",
            "description": "The globally unique identifier for glossary term.",
            "required": true,
            "type": "string"
          },
          {
            "name": "body",
            "in": "body",
            "description": "An array of related object IDs to which the term has to be associated.",
            "required": true,
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasRelatedObjectId"
              },
              "x-ms-identifiers": []
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_AssignTermToEntities": {
            "$ref": "./examples/Glossary_AssignTermToEntities.json"
          }
        }
      },
      "delete": {
        "operationId": "Glossary_DeleteTermAssignmentFromEntities",
        "description": "Delete the term assignment for the given list of related objects.",
        "parameters": [
          {
            "name": "termId",
            "in": "path",
            "description": "The globally unique identifier for glossary term.",
            "required": true,
            "type": "string"
          },
          {
            "name": "body",
            "in": "body",
            "description": "An array of related object IDs from which the term has to be dissociated.",
            "required": true,
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasRelatedObjectId"
              },
              "x-ms-identifiers": []
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_RemoveTermAssignmentFromEntities": {
            "$ref": "./examples/Glossary_RemoveTermAssignmentFromEntities.json"
          }
        }
      }
    },
    "/atlas/v2/glossary/terms/{termId}/related": {
      "get": {
        "operationId": "Glossary_ListRelatedTerms",
        "description": "Get all related terms for a specific term by its GUID. Limit, offset, and sort\nparameters are currently not being enabled and won't work even they are passed.",
        "parameters": [
          {
            "$ref": "#/parameters/AtlasApiVersionParameter"
          },
          {
            "name": "termId",
            "in": "path",
            "description": "The globally unique identifier for glossary term.",
            "required": true,
            "type": "string"
          },
          {
            "name": "limit",
            "in": "query",
            "description": "The page size - by default there is no paging.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "offset",
            "in": "query",
            "description": "The offset for pagination purpose.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "sort",
            "in": "query",
            "description": "The sort order, ASC (default) or DESC.",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "type": "object",
              "additionalProperties": {
                "items": {
                  "$ref": "#/definitions/AtlasRelatedTermHeader"
                },
                "type": "array",
                "x-ms-identifiers": []
              }
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Glossary_ListRelatedTerms": {
            "$ref": "./examples/Glossary_ListRelatedTerms.json"
          }
        }
      }
    },
    "/atlas/v2/lineage/{guid}": {
      "get": {
        "operationId": "Lineage_Get",
        "description": "Get lineage info of the entity specified by GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          },
          {
            "name": "depth",
            "in": "query",
            "description": "The number of hops for lineage.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "direction",
            "in": "query",
            "description": "The direction of the lineage, which could be INPUT, OUTPUT or BOTH.",
            "required": true,
            "type": "string",
            "enum": [
              "INPUT",
              "OUTPUT",
              "BOTH"
            ],
            "x-ms-enum": {
              "name": "LineageDirection",
              "modelAsString": true,
              "values": [
                {
                  "name": "Input",
                  "value": "INPUT",
                  "description": "input"
                },
                {
                  "name": "Output",
                  "value": "OUTPUT",
                  "description": "output"
                },
                {
                  "name": "Both",
                  "value": "BOTH",
                  "description": "both"
                }
              ]
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasLineageInfo"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Lineage_Get": {
            "$ref": "./examples/Lineage_Get.json"
          }
        }
      }
    },
    "/atlas/v2/lineage/uniqueAttribute/type/{typeName}": {
      "get": {
        "operationId": "Lineage_GetByUniqueAttribute",
        "description": "Return lineage info about entity.\n\nIn addition to the typeName path parameter,\nattribute key-value pair(s) can be provided in the following\nformat\n\nattr:[attrName]=[attrValue]\n\nNOTE: The attrName and attrValue should be\nunique across entities, eg. qualifiedName.\n\nThe REST request would look\nsomething like this:\n\nGET\n/v2/lineage/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue.",
        "parameters": [
          {
            "name": "typeName",
            "in": "path",
            "description": "The name of the type.",
            "required": true,
            "type": "string"
          },
          {
            "name": "depth",
            "in": "query",
            "description": "The number of hops for lineage.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "direction",
            "in": "query",
            "description": "The direction of the lineage, which could be INPUT, OUTPUT or BOTH.",
            "required": true,
            "type": "string",
            "enum": [
              "INPUT",
              "OUTPUT",
              "BOTH"
            ],
            "x-ms-enum": {
              "name": "LineageDirection",
              "modelAsString": true,
              "values": [
                {
                  "name": "Input",
                  "value": "INPUT",
                  "description": "input"
                },
                {
                  "name": "Output",
                  "value": "OUTPUT",
                  "description": "output"
                },
                {
                  "name": "Both",
                  "value": "BOTH",
                  "description": "both"
                }
              ]
            }
          },
          {
            "name": "attr:qualifiedName",
            "in": "query",
            "description": "The qualified name of the entity. (This is only an example. qualifiedName can\nbe changed to other unique attributes)",
            "required": false,
            "type": "string",
            "x-ms-client-name": "attribute"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasLineageInfo"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Lineage_GetByUniqueAttribute": {
            "$ref": "./examples/Lineage_GetByUniqueAttribute.json"
          }
        }
      }
    },
    "/atlas/v2/relationship": {
      "put": {
        "operationId": "Relationship_Update",
        "description": "Update an existing relationship between entities.",
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AtlasRelationship"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasRelationship"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Relationship_Update": {
            "$ref": "./examples/Relationship_Update.json"
          }
        }
      },
      "post": {
        "operationId": "Relationship_Create",
        "description": "Create a new relationship between entities.",
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AtlasRelationship"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasRelationship"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Relationship_Create": {
            "$ref": "./examples/Relationship_Create.json"
          }
        }
      }
    },
    "/atlas/v2/relationship/guid/{guid}": {
      "get": {
        "operationId": "Relationship_Get",
        "description": "Get relationship information between entities by its GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the relationship.",
            "required": true,
            "type": "string"
          },
          {
            "name": "extendedInfo",
            "in": "query",
            "description": "Limits whether includes extended information.",
            "required": false,
            "type": "boolean"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasRelationshipWithExtInfo"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Relationship_Get": {
            "$ref": "./examples/Relationship_Get.json"
          }
        }
      },
      "delete": {
        "operationId": "Relationship_Delete",
        "description": "Delete a relationship between entities by its GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the relationship.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Relationship_Delete": {
            "$ref": "./examples/Relationship_Delete.json"
          }
        }
      }
    },
    "/atlas/v2/types/businessmetadatadef/guid/{guid}": {
      "get": {
        "operationId": "Type_GetBusinessMetadataDefByGuid",
        "description": "Get the businessMetadata definition for the given guid.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "businessMetadata guid",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasBusinessMetadataDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetBusinessMetadataDefByGuid": {
            "$ref": "./examples/Type_GetBusinessMetadataDefByGuid.json"
          }
        }
      }
    },
    "/atlas/v2/types/businessmetadatadef/name/{name}": {
      "get": {
        "operationId": "Type_GetBusinessMetadataDefByName",
        "description": "Get the businessMetadata definition by it's name (unique).",
        "parameters": [
          {
            "name": "name",
            "in": "path",
            "description": "businessMetadata name",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasBusinessMetadataDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetBusinessMetadataDefByName": {
            "$ref": "./examples/Type_GetBusinessMetadataDefByName.json"
          }
        }
      }
    },
    "/atlas/v2/types/classificationdef/guid/{guid}": {
      "get": {
        "operationId": "Type_GetClassificationDefByGuid",
        "description": "Get the classification definition for the given GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the classification.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasClassificationDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetClassificationDefByGuid": {
            "$ref": "./examples/Type_GetClassificationDefByGuid.json"
          }
        }
      }
    },
    "/atlas/v2/types/classificationdef/name/{name}": {
      "get": {
        "operationId": "Type_GetClassificationDefByName",
        "description": "Get the classification definition by its name (unique).",
        "parameters": [
          {
            "name": "name",
            "in": "path",
            "description": "The name of the classification.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasClassificationDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetClassificationDefByName": {
            "$ref": "./examples/Type_GetClassificationDefByName.json"
          }
        }
      }
    },
    "/atlas/v2/types/entitydef/guid/{guid}": {
      "get": {
        "operationId": "Type_GetEntityDefByGuid",
        "description": "Get the Entity definition for the given GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasEntityDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetEntityDefByGuid": {
            "$ref": "./examples/Type_GetEntityDefByGuid.json"
          }
        }
      }
    },
    "/atlas/v2/types/entitydef/name/{name}": {
      "get": {
        "operationId": "Type_GetEntityDefByName",
        "description": "Get the entity definition by its name (unique).",
        "parameters": [
          {
            "name": "name",
            "in": "path",
            "description": "The name of the entity.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasEntityDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetEntityDefByName": {
            "$ref": "./examples/Type_GetEntityDefByName.json"
          }
        }
      }
    },
    "/atlas/v2/types/enumdef/guid/{guid}": {
      "get": {
        "operationId": "Type_GetEnumDefByGuid",
        "description": "Get the enum definition for the given GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the enum.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasEnumDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetEnumDefByGuid": {
            "$ref": "./examples/Type_GetEnumDefByGuid.json"
          }
        }
      }
    },
    "/atlas/v2/types/enumdef/name/{name}": {
      "get": {
        "operationId": "Type_GetEnumDefByName",
        "description": "Get the enum definition by its name (unique).",
        "parameters": [
          {
            "name": "name",
            "in": "path",
            "description": "The name of the enum.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasEnumDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetEnumDefByName": {
            "$ref": "./examples/Type_GetEnumDefByName.json"
          }
        }
      }
    },
    "/atlas/v2/types/relationshipdef/guid/{guid}": {
      "get": {
        "operationId": "Type_GetRelationshipDefByGuid",
        "description": "Get the relationship definition for the given GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the relationship.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasRelationshipDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetRelationshipDefByGuid": {
            "$ref": "./examples/Type_GetRelationshipDefByGuid.json"
          }
        }
      }
    },
    "/atlas/v2/types/relationshipdef/name/{name}": {
      "get": {
        "operationId": "Type_GetRelationshipDefByName",
        "description": "Get the relationship definition by its name (unique).",
        "parameters": [
          {
            "name": "name",
            "in": "path",
            "description": "The name of the relationship.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasRelationshipDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetRelationshipDefByName": {
            "$ref": "./examples/Type_GetRelationshipDefByName.json"
          }
        }
      }
    },
    "/atlas/v2/types/structdef/guid/{guid}": {
      "get": {
        "operationId": "Type_GetStructDefByGuid",
        "description": "Get the struct definition for the given GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the struct.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasStructDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetStructDefByGuid": {
            "$ref": "./examples/Type_GetStructDefByGuid.json"
          }
        }
      }
    },
    "/atlas/v2/types/structdef/name/{name}": {
      "get": {
        "operationId": "Type_GetStructDefByName",
        "description": "Get the struct definition by its name (unique).",
        "parameters": [
          {
            "name": "name",
            "in": "path",
            "description": "The name of the struct.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasStructDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetStructDefByName": {
            "$ref": "./examples/Type_GetStructDefByName.json"
          }
        }
      }
    },
    "/atlas/v2/types/typedef/guid/{guid}": {
      "get": {
        "operationId": "Type_GetByGuid",
        "description": "Get the type definition for the given GUID.",
        "parameters": [
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the type.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasTypeDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetByGuid": {
            "$ref": "./examples/Type_GetByGuid.json"
          }
        }
      }
    },
    "/atlas/v2/types/typedef/name/{name}": {
      "get": {
        "operationId": "Type_GetByName",
        "description": "Get the type definition by its name (unique).",
        "parameters": [
          {
            "name": "name",
            "in": "path",
            "description": "The name of the type.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasTypeDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetByName": {
            "$ref": "./examples/Type_GetByName.json"
          }
        }
      },
      "delete": {
        "operationId": "Type_Delete",
        "description": "Delete API for type identified by its name.",
        "parameters": [
          {
            "name": "name",
            "in": "path",
            "description": "The name of the type.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_Delete": {
            "$ref": "./examples/Type_Delete.json"
          }
        }
      }
    },
    "/atlas/v2/types/typedefs": {
      "get": {
        "operationId": "Type_List",
        "description": "List all type definitions in bulk.",
        "parameters": [
          {
            "$ref": "#/parameters/AtlasApiVersionParameter"
          },
          {
            "name": "includeTermTemplate",
            "in": "query",
            "description": "Whether include termtemplatedef when return all typedefs.\nThis is always true\nwhen search filter type=term_template",
            "required": false,
            "type": "boolean"
          },
          {
            "name": "type",
            "in": "query",
            "description": "Typedef name as search filter when get typedefs.",
            "required": false,
            "type": "string",
            "enum": [
              "PRIMITIVE",
              "OBJECT_ID_TYPE",
              "ENUM",
              "STRUCT",
              "CLASSIFICATION",
              "ENTITY",
              "ARRAY",
              "MAP",
              "RELATIONSHIP",
              "TERM_TEMPLATE"
            ],
            "x-ms-enum": {
              "name": "TypeCategory",
              "modelAsString": true,
              "values": [
                {
                  "name": "Primitive",
                  "value": "PRIMITIVE",
                  "description": "primitive"
                },
                {
                  "name": "ObjectIdType",
                  "value": "OBJECT_ID_TYPE",
                  "description": "object id type"
                },
                {
                  "name": "Enum",
                  "value": "ENUM",
                  "description": "enum"
                },
                {
                  "name": "Struct",
                  "value": "STRUCT",
                  "description": "struct"
                },
                {
                  "name": "Classification",
                  "value": "CLASSIFICATION",
                  "description": "classification"
                },
                {
                  "name": "Entity",
                  "value": "ENTITY",
                  "description": "entity"
                },
                {
                  "name": "Array",
                  "value": "ARRAY",
                  "description": "array"
                },
                {
                  "name": "Map",
                  "value": "MAP",
                  "description": "map"
                },
                {
                  "name": "Relationship",
                  "value": "RELATIONSHIP",
                  "description": "relationship"
                },
                {
                  "name": "TermTemplate",
                  "value": "TERM_TEMPLATE",
                  "description": "term template"
                }
              ]
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasTypesDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_List": {
            "$ref": "./examples/Type_List.json"
          },
          "Type_ListEnumDefs": {
            "$ref": "./examples/Type_ListEnumDefs.json"
          },
          "Type_ListTermTemplateDefs": {
            "$ref": "./examples/Type_ListTermTemplateDefs.json"
          }
        }
      },
      "put": {
        "operationId": "Type_BulkUpdate",
        "description": "Update all types in bulk, changes detected in the type definitions would be\npersisted.",
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AtlasTypesDef"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasTypesDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_BulkUpdate": {
            "$ref": "./examples/Type_BulkUpdate.json"
          }
        }
      },
      "post": {
        "operationId": "Type_BulkCreate",
        "description": "Create all atlas type definitions in bulk, only new definitions will be\ncreated.\nAny changes to the existing definitions will be discarded.",
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AtlasTypesDef"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasTypesDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_BulkCreate": {
            "$ref": "./examples/Type_BulkCreate.json"
          },
          "Type_BulkCreateBusinessMetadataDefs": {
            "$ref": "./examples/Type_BulkCreateBusinessMetadataDefs.json"
          }
        }
      },
      "delete": {
        "operationId": "Type_BulkDelete",
        "description": "Delete API for all types in bulk.",
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AtlasTypesDef"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "There is no content to send for this request, but the headers may be useful. "
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_BulkDelete": {
            "$ref": "./examples/Type_BulkDelete.json"
          }
        }
      }
    },
    "/atlas/v2/types/typedefs/headers": {
      "get": {
        "operationId": "Type_ListHeaders",
        "description": "List all type definitions returned as a list of minimal information header.",
        "parameters": [
          {
            "$ref": "#/parameters/AtlasApiVersionParameter"
          },
          {
            "name": "includeTermTemplate",
            "in": "query",
            "description": "Whether include termtemplatedef when return all typedefs.\nThis is always true\nwhen search filter type=term_template",
            "required": false,
            "type": "boolean"
          },
          {
            "name": "type",
            "in": "query",
            "description": "Typedef name as search filter when get typedefs.",
            "required": false,
            "type": "string",
            "enum": [
              "PRIMITIVE",
              "OBJECT_ID_TYPE",
              "ENUM",
              "STRUCT",
              "CLASSIFICATION",
              "ENTITY",
              "ARRAY",
              "MAP",
              "RELATIONSHIP",
              "TERM_TEMPLATE"
            ],
            "x-ms-enum": {
              "name": "TypeCategory",
              "modelAsString": true,
              "values": [
                {
                  "name": "Primitive",
                  "value": "PRIMITIVE",
                  "description": "primitive"
                },
                {
                  "name": "ObjectIdType",
                  "value": "OBJECT_ID_TYPE",
                  "description": "object id type"
                },
                {
                  "name": "Enum",
                  "value": "ENUM",
                  "description": "enum"
                },
                {
                  "name": "Struct",
                  "value": "STRUCT",
                  "description": "struct"
                },
                {
                  "name": "Classification",
                  "value": "CLASSIFICATION",
                  "description": "classification"
                },
                {
                  "name": "Entity",
                  "value": "ENTITY",
                  "description": "entity"
                },
                {
                  "name": "Array",
                  "value": "ARRAY",
                  "description": "array"
                },
                {
                  "name": "Map",
                  "value": "MAP",
                  "description": "map"
                },
                {
                  "name": "Relationship",
                  "value": "RELATIONSHIP",
                  "description": "relationship"
                },
                {
                  "name": "TermTemplate",
                  "value": "TERM_TEMPLATE",
                  "description": "term template"
                }
              ]
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/AtlasTypeDefHeader"
              },
              "x-ms-identifiers": []
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_ListHeaders": {
            "$ref": "./examples/Type_ListHeaders.json"
          }
        }
      }
    },
    "/entity/moveTo": {
      "post": {
        "operationId": "Entity_MoveEntitiesToCollection",
        "description": "Move existing entities to the target collection.",
        "parameters": [
          {
            "$ref": "#/parameters/Azure.Core.Foundations.ApiVersionParameter"
          },
          {
            "name": "collectionId",
            "in": "query",
            "description": "The collection where entities will be moved to.",
            "required": true,
            "type": "string"
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/MoveEntitiesOptions"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/EntityMutationResult"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Entity_MoveEntitiesToCollection": {
            "$ref": "./examples/Entity_MoveEntitiesToCollection.json"
          }
        }
      }
    },
    "/lineage/{guid}/next": {
      "get": {
        "operationId": "Lineage_GetNextPage",
        "description": "Return immediate next page lineage info about entity with pagination",
        "parameters": [
          {
            "$ref": "#/parameters/Azure.Core.Foundations.ApiVersionParameter"
          },
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the entity.",
            "required": true,
            "type": "string"
          },
          {
            "name": "direction",
            "in": "query",
            "description": "The direction of the lineage, which could be INPUT, OUTPUT or BOTH.",
            "required": true,
            "type": "string",
            "enum": [
              "INPUT",
              "OUTPUT",
              "BOTH"
            ],
            "x-ms-enum": {
              "name": "LineageDirection",
              "modelAsString": true,
              "values": [
                {
                  "name": "Input",
                  "value": "INPUT",
                  "description": "input"
                },
                {
                  "name": "Output",
                  "value": "OUTPUT",
                  "description": "output"
                },
                {
                  "name": "Both",
                  "value": "BOTH",
                  "description": "both"
                }
              ]
            }
          },
          {
            "name": "offset",
            "in": "query",
            "description": "The offset for pagination purpose.",
            "required": false,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "limit",
            "in": "query",
            "description": "The page size - by default there is no paging.",
            "required": false,
            "type": "integer",
            "format": "int32"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AtlasLineageInfo"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Lineage_GetNextPage": {
            "$ref": "./examples/Lineage_GetNextPage.json"
          }
        }
      }
    },
    "/search/autocomplete": {
      "post": {
        "operationId": "Discovery_AutoComplete",
        "description": "Get auto complete options.",
        "parameters": [
          {
            "$ref": "#/parameters/Azure.Core.Foundations.ApiVersionParameter"
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/AutoCompleteOptions"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/AutoCompleteResult"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Discovery_AutoComplete": {
            "$ref": "./examples/Discovery_AutoComplete.json"
          }
        }
      }
    },
    "/search/query": {
      "post": {
        "operationId": "Discovery_Query",
        "description": "Get data using search.",
        "parameters": [
          {
            "$ref": "#/parameters/Azure.Core.Foundations.ApiVersionParameter"
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/QueryOptions"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/QueryResult"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Discovery_Query": {
            "$ref": "./examples/Discovery_Query.json"
          },
          "Discovery_Query_And": {
            "$ref": "./examples/Discovery_Query_And.json"
          },
          "Discovery_Query_AndOrNested": {
            "$ref": "./examples/Discovery_Query_AndOrNested.json"
          },
          "Discovery_Query_AssetType": {
            "$ref": "./examples/Discovery_Query_AssetType.json"
          },
          "Discovery_Query_Attribute": {
            "$ref": "./examples/Discovery_Query_Attribute.json"
          },
          "Discovery_Query_BusinessMetadataAttribute": {
            "$ref": "./examples/Discovery_Query_BusinessMetadataAttribute.json"
          },
          "Discovery_Query_Classification": {
            "$ref": "./examples/Discovery_Query_Classification.json"
          },
          "Discovery_Query_Collection": {
            "$ref": "./examples/Discovery_Query_Collection.json"
          },
          "Discovery_Query_Facet": {
            "$ref": "./examples/Discovery_Query_Facet.json"
          },
          "Discovery_Query_FileExtension": {
            "$ref": "./examples/Discovery_Query_FileExtension.json"
          },
          "Discovery_Query_GlossaryTerm": {
            "$ref": "./examples/Discovery_Query_GlossaryTerm.json"
          },
          "Discovery_Query_Id": {
            "$ref": "./examples/Discovery_Query_Id.json"
          },
          "Discovery_Query_Not": {
            "$ref": "./examples/Discovery_Query_Not.json"
          },
          "Discovery_Query_ObjectType": {
            "$ref": "./examples/Discovery_Query_ObjectType.json"
          },
          "Discovery_Query_PaginationContinuationPage": {
            "$ref": "./examples/Discovery_Query_PaginationContinuationPage.json"
          },
          "Discovery_Query_PaginationFirstPage": {
            "$ref": "./examples/Discovery_Query_PaginationFirstPage.json"
          },
          "Discovery_Query_PaginationLastPage": {
            "$ref": "./examples/Discovery_Query_PaginationLastPage.json"
          },
          "Discovery_Query_SystemTime": {
            "$ref": "./examples/Discovery_Query_SystemTime.json"
          },
          "Discovery_Query_Taxonomy": {
            "$ref": "./examples/Discovery_Query_Taxonomy.json"
          },
          "Discovery_Query_TermAssignment": {
            "$ref": "./examples/Discovery_Query_TermAssignment.json"
          },
          "Discovery_Query_Type": {
            "$ref": "./examples/Discovery_Query_Type.json"
          }
        }
      }
    },
    "/search/suggest": {
      "post": {
        "operationId": "Discovery_Suggest",
        "description": "Get search suggestions by query criteria.",
        "parameters": [
          {
            "$ref": "#/parameters/Azure.Core.Foundations.ApiVersionParameter"
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/SuggestOptions"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/SuggestResult"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Discovery_Suggest": {
            "$ref": "./examples/Discovery_Suggest.json"
          }
        }
      }
    },
    "/types/termtemplatedef/guid/{guid}": {
      "get": {
        "operationId": "Type_GetTermTemplateDefByGuid",
        "description": "Get the term template definition for the given GUID.",
        "parameters": [
          {
            "$ref": "#/parameters/Azure.Core.Foundations.ApiVersionParameter"
          },
          {
            "name": "guid",
            "in": "path",
            "description": "The globally unique identifier of the term template.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/TermTemplateDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetTermTemplateDefByGuid": {
            "$ref": "./examples/Type_GetTermTemplateDefByGuid.json"
          }
        }
      }
    },
    "/types/termtemplatedef/name/{name}": {
      "get": {
        "operationId": "Type_GetTermTemplateDefByName",
        "description": "Get the term template definition by its name (unique).",
        "parameters": [
          {
            "$ref": "#/parameters/Azure.Core.Foundations.ApiVersionParameter"
          },
          {
            "name": "name",
            "in": "path",
            "description": "The unique name of the term template.",
            "required": true,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The request has succeeded.",
            "schema": {
              "$ref": "#/definitions/TermTemplateDef"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/AtlasErrorResponse"
            }
          }
        },
        "x-ms-examples": {
          "Type_GetTermTemplateDefByName": {
            "$ref": "./examples/Type_GetTermTemplateDefByName.json"
          }
        }
      }
    }
  },
  "definitions": {
    "AtlasAttributeDef": {
      "type": "object",
      "description": "class that captures details of a struct-attribute.",
      "properties": {
        "cardinality": {
          "$ref": "#/definitions/CardinalityValue",
          "description": "single-valued attribute or multi-valued attribute."
        },
        "constraints": {
          "type": "array",
          "description": "An array of constraints.",
          "items": {
            "$ref": "#/definitions/AtlasConstraintDef"
          },
          "x-ms-identifiers": []
        },
        "defaultValue": {
          "type": "string",
          "description": "The default value of the attribute."
        },
        "description": {
          "type": "string",
          "description": "The description of the attribute."
        },
        "includeInNotification": {
          "type": "boolean",
          "description": "Determines if it is included in notification."
        },
        "isIndexable": {
          "type": "boolean",
          "description": "Determines if it is indexable."
        },
        "isOptional": {
          "type": "boolean",
          "description": "Determines if it is optional."
        },
        "isUnique": {
          "type": "boolean",
          "description": "Determines if it unique."
        },
        "name": {
          "type": "string",
          "description": "The name of the attribute."
        },
        "options": {
          "type": "object",
          "description": "The options for the attribute.",
          "additionalProperties": {
            "type": "string"
          }
        },
        "typeName": {
          "type": "string",
          "description": "The name of the type."
        },
        "valuesMaxCount": {
          "type": "integer",
          "format": "int32",
          "description": "The maximum count of the values."
        },
        "valuesMinCount": {
          "type": "integer",
          "format": "int32",
          "description": "The minimum count of the values."
        }
      }
    },
    "AtlasBusinessMetadataDef": {
      "type": "object",
      "description": "class that captures details of a struct-type.",
      "properties": {
        "category": {
          "$ref": "#/definitions/TypeCategory",
          "description": "The enum of type category."
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The created time of the record."
        },
        "createdBy": {
          "type": "string",
          "description": "The user who created the record."
        },
        "dateFormatter": {
          "$ref": "#/definitions/DateFormat",
          "description": "The date format."
        },
        "description": {
          "type": "string",
          "description": "The description of the type definition."
        },
        "guid": {
          "type": "string",
          "description": "The GUID of the type definition."
        },
        "name": {
          "type": "string",
          "description": "The name of the type definition."
        },
        "options": {
          "type": "object",
          "description": "The options for the type definition.",
          "additionalProperties": {
            "type": "string"
          }
        },
        "serviceType": {
          "type": "string",
          "description": "The service type."
        },
        "typeVersion": {
          "type": "string",
          "description": "The version of the type."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The update time of the record."
        },
        "updatedBy": {
          "type": "string",
          "description": "The user who updated the record."
        },
        "version": {
          "type": "integer",
          "format": "int64",
          "description": "The version of the record."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "attributeDefs": {
          "type": "array",
          "description": "An array of attribute definitions.",
          "items": {
            "$ref": "#/definitions/AtlasAttributeDef"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "AtlasClassification": {
      "type": "object",
      "description": "An instance of a classification; it doesn't have an identity, this object\nexists only when associated with an entity.",
      "properties": {
        "attributes": {
          "type": "object",
          "description": "The attributes of the struct.",
          "additionalProperties": {}
        },
        "typeName": {
          "type": "string",
          "description": "The name of the type."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "entityGuid": {
          "type": "string",
          "description": "The GUID of the entity."
        },
        "entityStatus": {
          "$ref": "#/definitions/EntityStatus",
          "description": "Status of the entity - can be active or deleted. Deleted entities are not\nremoved."
        },
        "removePropagationsOnEntityDelete": {
          "type": "boolean",
          "description": "Determines if propagations will be removed on entity deletion."
        },
        "validityPeriods": {
          "type": "array",
          "description": "An array of time boundaries indicating validity periods.",
          "items": {
            "$ref": "#/definitions/TimeBoundary"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "AtlasClassificationDef": {
      "type": "object",
      "description": "class that captures details of a classification-type.",
      "properties": {
        "category": {
          "$ref": "#/definitions/TypeCategory",
          "description": "The enum of type category."
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The created time of the record."
        },
        "createdBy": {
          "type": "string",
          "description": "The user who created the record."
        },
        "dateFormatter": {
          "$ref": "#/definitions/DateFormat",
          "description": "The date format."
        },
        "description": {
          "type": "string",
          "description": "The description of the type definition."
        },
        "guid": {
          "type": "string",
          "description": "The GUID of the type definition."
        },
        "name": {
          "type": "string",
          "description": "The name of the type definition."
        },
        "options": {
          "type": "object",
          "description": "The options for the type definition.",
          "additionalProperties": {
            "type": "string"
          }
        },
        "serviceType": {
          "type": "string",
          "description": "The service type."
        },
        "typeVersion": {
          "type": "string",
          "description": "The version of the type."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The update time of the record."
        },
        "updatedBy": {
          "type": "string",
          "description": "The user who updated the record."
        },
        "version": {
          "type": "integer",
          "format": "int64",
          "description": "The version of the record."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "attributeDefs": {
          "type": "array",
          "description": "An array of attribute definitions.",
          "items": {
            "$ref": "#/definitions/AtlasAttributeDef"
          },
          "x-ms-identifiers": []
        },
        "entityTypes": {
          "type": "array",
          "description": "Specifying a list of entityType names in the classificationDef, ensures that\nclassifications can\nonly be applied to those entityTypes.\n\nAny subtypes of the entity types inherit the restriction.\n\nAny classificationDef subtypes inherit the parents entityTypes restrictions.\n\nAny classificationDef subtypes can further restrict the parents entityTypes\nrestrictions by specifying a subset of the entityTypes.\n\nAn empty entityTypes list when there are no parent restrictions means there are no\nrestrictions.\n\nAn empty entityTypes list when there are parent\nrestrictions means that the subtype picks up the parents\nrestrictions.\n\nIf a list of entityTypes are supplied, where one inherits\nfrom another, this will be rejected. This should encourage cleaner\nclassificationsDefs.\n",
          "items": {
            "type": "string"
          }
        },
        "subTypes": {
          "type": "array",
          "description": "An array of sub types.",
          "items": {
            "type": "string"
          }
        },
        "superTypes": {
          "type": "array",
          "description": "An array of super types.",
          "items": {
            "type": "string"
          }
        }
      }
    },
    "AtlasClassifications": {
      "type": "object",
      "description": "REST serialization friendly list.",
      "properties": {
        "list": {
          "type": "array",
          "description": "An array of objects.",
          "items": {}
        },
        "pageSize": {
          "type": "integer",
          "format": "int32",
          "description": "The size of the page."
        },
        "sortBy": {
          "type": "string",
          "description": "The sorted by field."
        },
        "sortType": {
          "$ref": "#/definitions/SortType",
          "description": "to specify whether the result should be sorted? If yes, whether asc or desc."
        },
        "startIndex": {
          "type": "integer",
          "format": "int32",
          "description": "The start index of the page."
        },
        "totalCount": {
          "type": "integer",
          "format": "int32",
          "description": "The total count of items."
        }
      }
    },
    "AtlasConstraintDef": {
      "type": "object",
      "description": "class that captures details of a constraint.",
      "properties": {
        "params": {
          "type": "object",
          "description": "The parameters of the constraint definition.",
          "additionalProperties": {}
        },
        "type": {
          "type": "string",
          "description": "The type of the constraint."
        }
      }
    },
    "AtlasEntitiesWithExtInfo": {
      "type": "object",
      "description": "An instance of an entity along with extended info - like hive_table,\nhive_database.",
      "properties": {
        "referredEntities": {
          "type": "object",
          "description": "The referred entities.",
          "additionalProperties": {
            "$ref": "#/definitions/AtlasEntity"
          }
        },
        "entities": {
          "type": "array",
          "description": "An array of entities.",
          "items": {
            "$ref": "#/definitions/AtlasEntity"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "AtlasEntity": {
      "type": "object",
      "description": "An instance of an entity - like hive_table, hive_database.",
      "properties": {
        "attributes": {
          "type": "object",
          "description": "The attributes of the struct.",
          "additionalProperties": {}
        },
        "typeName": {
          "type": "string",
          "description": "The name of the type."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "businessAttributes": {
          "type": "object",
          "description": "Business attributes",
          "additionalProperties": {}
        },
        "classifications": {
          "type": "array",
          "description": "An array of classifications.",
          "items": {
            "$ref": "#/definitions/AtlasClassification"
          },
          "x-ms-identifiers": []
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The created time of the record."
        },
        "createdBy": {
          "type": "string",
          "description": "The user who created the record."
        },
        "customAttributes": {
          "type": "object",
          "description": "Custom Attribute",
          "additionalProperties": {
            "type": "string"
          }
        },
        "guid": {
          "type": "string",
          "description": "The GUID of the entity."
        },
        "homeId": {
          "type": "string",
          "description": "The home ID of the entity."
        },
        "collectionId": {
          "type": "string",
          "description": "The collection ID of the entity.",
          "readOnly": true
        },
        "isIncomplete": {
          "type": "boolean",
          "description": "Whether it is a shell entity"
        },
        "labels": {
          "type": "array",
          "description": "labels",
          "items": {
            "type": "string"
          }
        },
        "meanings": {
          "type": "array",
          "description": "An array of term assignment headers indicating the meanings of the entity.",
          "items": {
            "$ref": "#/definitions/AtlasTermAssignmentHeader"
          },
          "x-ms-identifiers": []
        },
        "provenanceType": {
          "type": "integer",
          "format": "int32",
          "description": "Used to record the provenance of an instance of an entity or relationship."
        },
        "proxy": {
          "type": "boolean",
          "description": "Determines if there's a proxy."
        },
        "relationshipAttributes": {
          "type": "object",
          "description": "The attributes of relationship.",
          "additionalProperties": {}
        },
        "status": {
          "$ref": "#/definitions/EntityStatus",
          "description": "Status of the entity - can be active or deleted. Deleted entities are not\nremoved."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The update time of the record."
        },
        "updatedBy": {
          "type": "string",
          "description": "The user who updated the record."
        },
        "version": {
          "type": "integer",
          "format": "int64",
          "description": "The version of the entity."
        },
        "contacts": {
          "type": "object",
          "description": "The dictionary of contacts for entities. Key could be Expert or Owner.",
          "additionalProperties": {
            "items": {
              "$ref": "#/definitions/ContactInfo"
            },
            "type": "array"
          }
        }
      }
    },
    "AtlasEntityDef": {
      "type": "object",
      "description": "class that captures details of a entity-type.",
      "properties": {
        "category": {
          "$ref": "#/definitions/TypeCategory",
          "description": "The enum of type category."
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The created time of the record."
        },
        "createdBy": {
          "type": "string",
          "description": "The user who created the record."
        },
        "dateFormatter": {
          "$ref": "#/definitions/DateFormat",
          "description": "The date format."
        },
        "description": {
          "type": "string",
          "description": "The description of the type definition."
        },
        "guid": {
          "type": "string",
          "description": "The GUID of the type definition."
        },
        "name": {
          "type": "string",
          "description": "The name of the type definition."
        },
        "options": {
          "type": "object",
          "description": "The options for the type definition.",
          "additionalProperties": {
            "type": "string"
          }
        },
        "serviceType": {
          "type": "string",
          "description": "The service type."
        },
        "typeVersion": {
          "type": "string",
          "description": "The version of the type."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The update time of the record."
        },
        "updatedBy": {
          "type": "string",
          "description": "The user who updated the record."
        },
        "version": {
          "type": "integer",
          "format": "int64",
          "description": "The version of the record."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "attributeDefs": {
          "type": "array",
          "description": "An array of attribute definitions.",
          "items": {
            "$ref": "#/definitions/AtlasAttributeDef"
          },
          "x-ms-identifiers": []
        },
        "subTypes": {
          "type": "array",
          "description": "An array of sub types.",
          "items": {
            "type": "string"
          }
        },
        "superTypes": {
          "type": "array",
          "description": "An array of super types.",
          "items": {
            "type": "string"
          }
        },
        "relationshipAttributeDefs": {
          "type": "array",
          "description": "An array of relationship attributes.",
          "items": {
            "$ref": "#/definitions/AtlasRelationshipAttributeDef"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "AtlasEntityHeader": {
      "type": "object",
      "description": "An instance of an entity - like hive_table, hive_database.",
      "properties": {
        "attributes": {
          "type": "object",
          "description": "The attributes of the struct.",
          "additionalProperties": {}
        },
        "typeName": {
          "type": "string",
          "description": "The name of the type."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "classificationNames": {
          "type": "array",
          "description": "An array of classification names.",
          "items": {
            "type": "string"
          }
        },
        "classifications": {
          "type": "array",
          "description": "An array of classifications.",
          "items": {
            "$ref": "#/definitions/AtlasClassification"
          },
          "x-ms-identifiers": []
        },
        "displayText": {
          "type": "string",
          "description": "The display text."
        },
        "guid": {
          "type": "string",
          "description": "The GUID of the record."
        },
        "isIncomplete": {
          "type": "boolean",
          "description": "Whether it is a shell entity"
        },
        "labels": {
          "type": "array",
          "description": "labels",
          "items": {
            "type": "string"
          }
        },
        "meaningNames": {
          "type": "array",
          "description": "An array of meanings.",
          "items": {
            "type": "string"
          }
        },
        "meanings": {
          "type": "array",
          "description": "An array of term assignment headers.",
          "items": {
            "$ref": "#/definitions/AtlasTermAssignmentHeader"
          },
          "x-ms-identifiers": []
        },
        "status": {
          "$ref": "#/definitions/EntityStatus",
          "description": "Status of the entity - can be active or deleted. Deleted entities are not\nremoved."
        }
      }
    },
    "AtlasEntityHeaders": {
      "type": "object",
      "description": "An instance of an entity header map.",
      "properties": {
        "guidHeaderMap": {
          "type": "object",
          "description": "The description of the guid header map,",
          "additionalProperties": {
            "$ref": "#/definitions/AtlasEntityHeader"
          }
        }
      }
    },
    "AtlasEntityWithExtInfo": {
      "type": "object",
      "description": "An instance of an entity along with extended info - like hive_table,\nhive_database.",
      "properties": {
        "referredEntities": {
          "type": "object",
          "description": "The referred entities.",
          "additionalProperties": {
            "$ref": "#/definitions/AtlasEntity"
          }
        },
        "entity": {
          "$ref": "#/definitions/AtlasEntity",
          "description": "An instance of an entity - like hive_table, hive_database."
        }
      }
    },
    "AtlasEnumDef": {
      "type": "object",
      "description": "class that captures details of an enum-type.",
      "properties": {
        "category": {
          "$ref": "#/definitions/TypeCategory",
          "description": "The enum of type category."
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The created time of the record."
        },
        "createdBy": {
          "type": "string",
          "description": "The user who created the record."
        },
        "dateFormatter": {
          "$ref": "#/definitions/DateFormat",
          "description": "The date format."
        },
        "description": {
          "type": "string",
          "description": "The description of the type definition."
        },
        "guid": {
          "type": "string",
          "description": "The GUID of the type definition."
        },
        "name": {
          "type": "string",
          "description": "The name of the type definition."
        },
        "options": {
          "type": "object",
          "description": "The options for the type definition.",
          "additionalProperties": {
            "type": "string"
          }
        },
        "serviceType": {
          "type": "string",
          "description": "The service type."
        },
        "typeVersion": {
          "type": "string",
          "description": "The version of the type."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The update time of the record."
        },
        "updatedBy": {
          "type": "string",
          "description": "The user who updated the record."
        },
        "version": {
          "type": "integer",
          "format": "int64",
          "description": "The version of the record."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "defaultValue": {
          "type": "string",
          "description": "The default value."
        },
        "elementDefs": {
          "type": "array",
          "description": "An array of enum element definitions.",
          "items": {
            "$ref": "#/definitions/AtlasEnumElementDef"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "AtlasEnumElementDef": {
      "type": "object",
      "description": "class that captures details of an enum-element.",
      "properties": {
        "description": {
          "type": "string",
          "description": "The description of the enum element definition."
        },
        "ordinal": {
          "type": "integer",
          "format": "int32",
          "description": "The ordinal of the enum element definition."
        },
        "value": {
          "type": "string",
          "description": "The value of the enum element definition."
        }
      }
    },
    "AtlasErrorResponse": {
      "type": "object",
      "description": "An error response from the service",
      "properties": {
        "requestId": {
          "$ref": "#/definitions/Azure.Core.uuid",
          "description": "The request ID."
        },
        "errorCode": {
          "type": "string",
          "description": "The error code."
        },
        "errorMessage": {
          "type": "string",
          "description": "The error message."
        }
      }
    },
    "AtlasGlossary": {
      "type": "object",
      "description": "The glossary object.",
      "properties": {
        "guid": {
          "type": "string",
          "description": "The GUID of the object."
        },
        "classifications": {
          "type": "array",
          "description": "An array of classifications.",
          "items": {
            "$ref": "#/definitions/AtlasClassification"
          },
          "x-ms-identifiers": []
        },
        "longDescription": {
          "type": "string",
          "description": "The long version description."
        },
        "name": {
          "type": "string",
          "description": "The name of the glossary object."
        },
        "qualifiedName": {
          "type": "string",
          "description": "The qualified name of the glossary object."
        },
        "shortDescription": {
          "type": "string",
          "description": "The short version of description."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The created time of the record."
        },
        "createdBy": {
          "type": "string",
          "description": "The user who created the record."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The update time of the record."
        },
        "updatedBy": {
          "type": "string",
          "description": "The user who updated the record."
        },
        "categories": {
          "type": "array",
          "description": "An array of categories.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedCategoryHeader"
          },
          "x-ms-identifiers": []
        },
        "language": {
          "type": "string",
          "description": "The language of the glossary."
        },
        "terms": {
          "type": "array",
          "description": "An array of related term headers.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        },
        "usage": {
          "type": "string",
          "description": "The usage of the glossary."
        }
      }
    },
    "AtlasGlossaryCategory": {
      "type": "object",
      "description": "The glossary category.",
      "properties": {
        "guid": {
          "type": "string",
          "description": "The GUID of the object."
        },
        "classifications": {
          "type": "array",
          "description": "An array of classifications.",
          "items": {
            "$ref": "#/definitions/AtlasClassification"
          },
          "x-ms-identifiers": []
        },
        "longDescription": {
          "type": "string",
          "description": "The long version description."
        },
        "name": {
          "type": "string",
          "description": "The name of the glossary object."
        },
        "qualifiedName": {
          "type": "string",
          "description": "The qualified name of the glossary object."
        },
        "shortDescription": {
          "type": "string",
          "description": "The short version of description."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The created time of the record."
        },
        "createdBy": {
          "type": "string",
          "description": "The user who created the record."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The update time of the record."
        },
        "updatedBy": {
          "type": "string",
          "description": "The user who updated the record."
        },
        "anchor": {
          "$ref": "#/definitions/AtlasGlossaryHeader",
          "description": "The glossary header with basic information."
        },
        "childrenCategories": {
          "type": "array",
          "description": "An array of children categories.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedCategoryHeader"
          },
          "x-ms-identifiers": []
        },
        "parentCategory": {
          "$ref": "#/definitions/AtlasRelatedCategoryHeader",
          "description": "The header of the related category."
        },
        "terms": {
          "type": "array",
          "description": "An array of related term headers.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "AtlasGlossaryExtInfo": {
      "type": "object",
      "description": "The extended information of glossary.",
      "properties": {
        "guid": {
          "type": "string",
          "description": "The GUID of the object."
        },
        "classifications": {
          "type": "array",
          "description": "An array of classifications.",
          "items": {
            "$ref": "#/definitions/AtlasClassification"
          },
          "x-ms-identifiers": []
        },
        "longDescription": {
          "type": "string",
          "description": "The long version description."
        },
        "name": {
          "type": "string",
          "description": "The name of the glossary object."
        },
        "qualifiedName": {
          "type": "string",
          "description": "The qualified name of the glossary object."
        },
        "shortDescription": {
          "type": "string",
          "description": "The short version of description."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The created time of the record."
        },
        "createdBy": {
          "type": "string",
          "description": "The user who created the record."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The update time of the record."
        },
        "updatedBy": {
          "type": "string",
          "description": "The user who updated the record."
        },
        "categories": {
          "type": "array",
          "description": "An array of categories.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedCategoryHeader"
          },
          "x-ms-identifiers": []
        },
        "language": {
          "type": "string",
          "description": "The language of the glossary."
        },
        "terms": {
          "type": "array",
          "description": "An array of related term headers.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        },
        "usage": {
          "type": "string",
          "description": "The usage of the glossary."
        },
        "categoryInfo": {
          "type": "object",
          "description": "The glossary category information.",
          "additionalProperties": {
            "$ref": "#/definitions/AtlasGlossaryCategory"
          }
        },
        "termInfo": {
          "type": "object",
          "description": "The glossary term information.",
          "additionalProperties": {
            "$ref": "#/definitions/AtlasGlossaryTerm"
          }
        }
      }
    },
    "AtlasGlossaryHeader": {
      "type": "object",
      "description": "The glossary header with basic information.",
      "properties": {
        "displayText": {
          "type": "string",
          "description": "The display text."
        },
        "glossaryGuid": {
          "type": "string",
          "description": "The GUID of the glossary."
        },
        "relationGuid": {
          "type": "string",
          "description": "The GUID of the relationship."
        }
      }
    },
    "AtlasGlossaryTerm": {
      "type": "object",
      "description": "The glossary term.",
      "properties": {
        "guid": {
          "type": "string",
          "description": "The GUID of the object."
        },
        "classifications": {
          "type": "array",
          "description": "An array of classifications.",
          "items": {
            "$ref": "#/definitions/AtlasClassification"
          },
          "x-ms-identifiers": []
        },
        "longDescription": {
          "type": "string",
          "description": "The long version description."
        },
        "name": {
          "type": "string",
          "description": "The name of the glossary object."
        },
        "qualifiedName": {
          "type": "string",
          "description": "The qualified name of the glossary object."
        },
        "shortDescription": {
          "type": "string",
          "description": "The short version of description."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The created time of the record."
        },
        "createdBy": {
          "type": "string",
          "description": "The user who created the record."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The update time of the record."
        },
        "updatedBy": {
          "type": "string",
          "description": "The user who updated the record."
        },
        "abbreviation": {
          "type": "string",
          "description": "The abbreviation of the term."
        },
        "templateName": {
          "type": "array",
          "description": "The name of the template.",
          "items": {}
        },
        "anchor": {
          "$ref": "#/definitions/AtlasGlossaryHeader",
          "description": "The glossary header with basic information."
        },
        "antonyms": {
          "type": "array",
          "description": "An array of related term headers as antonyms.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        },
        "status": {
          "$ref": "#/definitions/TermStatus",
          "description": "Status of the AtlasGlossaryTerm"
        },
        "nickName": {
          "type": "string",
          "description": "The nick name of the term."
        },
        "hierarchyInfo": {
          "type": "array",
          "description": "The hierarchy information of the term.",
          "items": {
            "$ref": "#/definitions/PurviewObjectId"
          },
          "x-ms-identifiers": []
        },
        "resources": {
          "type": "array",
          "description": "An array of resource link for term",
          "items": {
            "$ref": "#/definitions/ResourceLink"
          },
          "x-ms-identifiers": []
        },
        "contacts": {
          "type": "object",
          "description": "The dictionary of contacts for terms. Key could be Expert or Steward.",
          "additionalProperties": {
            "items": {
              "$ref": "#/definitions/ContactInfo"
            },
            "type": "array"
          }
        },
        "attributes": {
          "type": "object",
          "description": "The custom attributes of the term, which is map<string,map<string,object>>.\nThe\nkey of the first layer map is term template name.",
          "additionalProperties": {
            "additionalProperties": {},
            "type": "object"
          }
        },
        "assignedEntities": {
          "type": "array",
          "description": "An array of related object IDs.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedObjectId"
          },
          "x-ms-identifiers": []
        },
        "categories": {
          "type": "array",
          "description": "An array of term categorization headers.",
          "items": {
            "$ref": "#/definitions/AtlasTermCategorizationHeader"
          },
          "x-ms-identifiers": []
        },
        "classifies": {
          "type": "array",
          "description": "An array of related term headers.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        },
        "examples": {
          "type": "array",
          "description": "An array of examples.",
          "items": {
            "type": "string"
          }
        },
        "isA": {
          "type": "array",
          "description": "An array of related term headers indicating the is-a relationship.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        },
        "preferredTerms": {
          "type": "array",
          "description": "An array of preferred related term headers.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        },
        "preferredToTerms": {
          "type": "array",
          "description": "An array of related term headers that are preferred to.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        },
        "replacedBy": {
          "type": "array",
          "description": "An array of related term headers that are replaced by.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        },
        "replacementTerms": {
          "type": "array",
          "description": "An array of related term headers for replacement.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        },
        "seeAlso": {
          "type": "array",
          "description": "An array of related term headers for see also.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        },
        "synonyms": {
          "type": "array",
          "description": "An array of related term headers as synonyms.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        },
        "translatedTerms": {
          "type": "array",
          "description": "An array of translated related term headers.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        },
        "translationTerms": {
          "type": "array",
          "description": "An array of related term headers for translation.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        },
        "usage": {
          "type": "string",
          "description": "The usage of the term."
        },
        "validValues": {
          "type": "array",
          "description": "An array of related term headers as valid values.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        },
        "validValuesFor": {
          "type": "array",
          "description": "An array of related term headers as valid values for other records.",
          "items": {
            "$ref": "#/definitions/AtlasRelatedTermHeader"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "AtlasLineageInfo": {
      "type": "object",
      "description": "The lineage information.",
      "properties": {
        "baseEntityGuid": {
          "type": "string",
          "description": "The GUID of the base entity."
        },
        "guidEntityMap": {
          "type": "object",
          "description": "The GUID entity map.",
          "additionalProperties": {
            "$ref": "#/definitions/AtlasEntityHeader"
          }
        },
        "widthCounts": {
          "type": "object",
          "description": "The entity count in specific direction.",
          "additionalProperties": {
            "additionalProperties": {},
            "type": "object"
          }
        },
        "lineageDepth": {
          "type": "integer",
          "format": "int32",
          "description": "The depth of lineage."
        },
        "lineageWidth": {
          "type": "integer",
          "format": "int32",
          "description": "The width of lineage."
        },
        "childrenCount": {
          "type": "integer",
          "format": "int32",
          "description": "The number of children node."
        },
        "lineageDirection": {
          "$ref": "#/definitions/LineageDirection",
          "description": "The enum of lineage direction."
        },
        "parentRelations": {
          "type": "array",
          "description": "An array of parentRelations relations.",
          "items": {
            "$ref": "#/definitions/ParentRelation"
          },
          "x-ms-identifiers": []
        },
        "relations": {
          "type": "array",
          "description": "An array of lineage relations.",
          "items": {
            "$ref": "#/definitions/LineageRelation"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "AtlasObjectId": {
      "type": "object",
      "description": "Reference to an object-instance of a type - like entity.",
      "properties": {
        "guid": {
          "type": "string",
          "description": "The GUID of the object."
        },
        "typeName": {
          "type": "string",
          "description": "The name of the type."
        },
        "uniqueAttributes": {
          "type": "object",
          "description": "The unique attributes of the object.",
          "additionalProperties": {}
        }
      }
    },
    "AtlasRelatedCategoryHeader": {
      "type": "object",
      "description": "The header of the related category.",
      "properties": {
        "categoryGuid": {
          "type": "string",
          "description": "The GUID of the category."
        },
        "description": {
          "type": "string",
          "description": "The description of the category header."
        },
        "displayText": {
          "type": "string",
          "description": "The display text."
        },
        "parentCategoryGuid": {
          "type": "string",
          "description": "The GUID of the parent category."
        },
        "relationGuid": {
          "type": "string",
          "description": "The GUID of the relationship."
        }
      }
    },
    "AtlasRelatedObjectId": {
      "type": "object",
      "description": "Reference to an object-instance of AtlasEntity type used in relationship\nattribute values",
      "properties": {
        "guid": {
          "type": "string",
          "description": "The GUID of the object."
        },
        "typeName": {
          "type": "string",
          "description": "The name of the type."
        },
        "uniqueAttributes": {
          "type": "object",
          "description": "The unique attributes of the object.",
          "additionalProperties": {}
        },
        "displayText": {
          "type": "string",
          "description": "The display text."
        },
        "entityStatus": {
          "$ref": "#/definitions/EntityStatus",
          "description": "Status of the entity - can be active or deleted. Deleted entities are not\nremoved."
        },
        "relationshipType": {
          "type": "string",
          "description": "Relationship type"
        },
        "relationshipAttributes": {
          "$ref": "#/definitions/AtlasStruct",
          "description": "Captures details of struct contents. Not instantiated directly, used only via\nAtlasEntity, AtlasClassification."
        },
        "relationshipGuid": {
          "$ref": "#/definitions/Azure.Core.uuid",
          "description": "The GUID of the relationship."
        },
        "relationshipStatus": {
          "$ref": "#/definitions/StatusAtlasRelationship",
          "description": "The enum of relationship status."
        }
      }
    },
    "AtlasRelatedTermHeader": {
      "type": "object",
      "description": "The header of the related term.",
      "properties": {
        "description": {
          "type": "string",
          "description": "The description of the related term."
        },
        "displayText": {
          "type": "string",
          "description": "The display text."
        },
        "expression": {
          "type": "string",
          "description": "The expression of the term."
        },
        "relationGuid": {
          "type": "string",
          "description": "The GUID of the relationship."
        },
        "status": {
          "$ref": "#/definitions/AtlasTermRelationshipStatus",
          "description": "The status of term relationship."
        },
        "steward": {
          "type": "string",
          "description": "The steward of the term."
        },
        "termGuid": {
          "type": "string",
          "description": "The GUID of the term."
        }
      }
    },
    "AtlasRelationship": {
      "type": "object",
      "description": "Atlas relationship instance.",
      "properties": {
        "attributes": {
          "type": "object",
          "description": "The attributes of the struct.",
          "additionalProperties": {}
        },
        "typeName": {
          "type": "string",
          "description": "The name of the type."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The created time of the record."
        },
        "createdBy": {
          "type": "string",
          "description": "The user who created the record."
        },
        "end1": {
          "$ref": "#/definitions/AtlasObjectId",
          "description": "Reference to an object-instance of a type - like entity."
        },
        "end2": {
          "$ref": "#/definitions/AtlasObjectId",
          "description": "Reference to an object-instance of a type - like entity."
        },
        "guid": {
          "type": "string",
          "description": "The GUID of the relationship."
        },
        "homeId": {
          "type": "string",
          "description": "The home ID of the relationship."
        },
        "label": {
          "type": "string",
          "description": "The label of the relationship."
        },
        "provenanceType": {
          "type": "integer",
          "format": "int32",
          "description": "Used to record the provenance of an instance of an entity or relationship"
        },
        "status": {
          "$ref": "#/definitions/StatusAtlasRelationship",
          "description": "The enum of relationship status."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The update time of the record."
        },
        "updatedBy": {
          "type": "string",
          "description": "The user who updated the record."
        },
        "version": {
          "type": "integer",
          "format": "int64",
          "description": "The version of the relationship."
        }
      }
    },
    "AtlasRelationshipAttributeDef": {
      "type": "object",
      "description": "The relationshipEndDef represents an end of the relationship. The end of the\nrelationship is defined by a type, an\nattribute name, cardinality and whether\nit  is the container end of the relationship.",
      "properties": {
        "cardinality": {
          "$ref": "#/definitions/CardinalityValue",
          "description": "single-valued attribute or multi-valued attribute."
        },
        "constraints": {
          "type": "array",
          "description": "An array of constraints.",
          "items": {
            "$ref": "#/definitions/AtlasConstraintDef"
          },
          "x-ms-identifiers": []
        },
        "defaultValue": {
          "type": "string",
          "description": "The default value of the attribute."
        },
        "description": {
          "type": "string",
          "description": "The description of the attribute."
        },
        "includeInNotification": {
          "type": "boolean",
          "description": "Determines if it is included in notification."
        },
        "isIndexable": {
          "type": "boolean",
          "description": "Determines if it is indexable."
        },
        "isOptional": {
          "type": "boolean",
          "description": "Determines if it is optional."
        },
        "isUnique": {
          "type": "boolean",
          "description": "Determines if it unique."
        },
        "name": {
          "type": "string",
          "description": "The name of the attribute."
        },
        "options": {
          "type": "object",
          "description": "The options for the attribute.",
          "additionalProperties": {
            "type": "string"
          }
        },
        "typeName": {
          "type": "string",
          "description": "The name of the type."
        },
        "valuesMaxCount": {
          "type": "integer",
          "format": "int32",
          "description": "The maximum count of the values."
        },
        "valuesMinCount": {
          "type": "integer",
          "format": "int32",
          "description": "The minimum count of the values."
        },
        "isLegacyAttribute": {
          "type": "boolean",
          "description": "Determines if it is a legacy attribute."
        },
        "relationshipTypeName": {
          "type": "string",
          "description": "The name of the relationship type."
        }
      }
    },
    "AtlasRelationshipDef": {
      "type": "object",
      "description": "AtlasRelationshipDef is a TypeDef that defines a relationship.\nAs with other typeDefs the AtlasRelationshipDef has a name. Once created the\nRelationshipDef has a guid.\nThe name and the guid are the 2 ways that the\nRelationshipDef is identified.\nRelationshipDefs have 2 ends, each of which\nspecify cardinality, an EntityDef type name and name and optionally\nwhether the\nend is a container.\nRelationshipDefs can have AttributeDefs - though only\nprimitive types are allowed. \nRelationshipDefs have a relationshipCategory\nspecifying the UML type of relationship required \nThe way EntityDefs and\nRelationshipDefs are intended to be used is that EntityDefs will define\nAttributeDefs these AttributeDefs\nwill not specify an EntityDef type name as\ntheir types.\nRelationshipDefs introduce new attributes to the entity\ninstances. For example\nEntityDef A might have attributes attr1,attr2,attr3\n\nEntityDef B might have attributes attr4,attr5,attr6 \nRelationshipDef\nAtoB might define 2 ends \n\nend1:  type A, name attr7\nend2:  type B, name attr8 \n\nWhen an instance of EntityDef A is created, it\nwill have attributes attr1,attr2,attr3,attr7 \nWhen an instance of EntityDef\nB is created, it will have attributes attr4,attr5,attr6,attr8\n\nIn this way\nrelationshipDefs can be authored separately from entityDefs and can inject\nrelationship attributes into\nthe entity instances",
      "properties": {
        "category": {
          "$ref": "#/definitions/TypeCategory",
          "description": "The enum of type category."
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The created time of the record."
        },
        "createdBy": {
          "type": "string",
          "description": "The user who created the record."
        },
        "dateFormatter": {
          "$ref": "#/definitions/DateFormat",
          "description": "The date format."
        },
        "description": {
          "type": "string",
          "description": "The description of the type definition."
        },
        "guid": {
          "type": "string",
          "description": "The GUID of the type definition."
        },
        "name": {
          "type": "string",
          "description": "The name of the type definition."
        },
        "options": {
          "type": "object",
          "description": "The options for the type definition.",
          "additionalProperties": {
            "type": "string"
          }
        },
        "serviceType": {
          "type": "string",
          "description": "The service type."
        },
        "typeVersion": {
          "type": "string",
          "description": "The version of the type."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The update time of the record."
        },
        "updatedBy": {
          "type": "string",
          "description": "The user who updated the record."
        },
        "version": {
          "type": "integer",
          "format": "int64",
          "description": "The version of the record."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "attributeDefs": {
          "type": "array",
          "description": "An array of attribute definitions.",
          "items": {
            "$ref": "#/definitions/AtlasAttributeDef"
          },
          "x-ms-identifiers": []
        },
        "endDef1": {
          "$ref": "#/definitions/AtlasRelationshipEndDef",
          "description": "The relationshipEndDef represents an end of the relationship. The end of the\nrelationship is defined by a type, an\nattribute name, cardinality and whether\nit  is the container end of the relationship."
        },
        "endDef2": {
          "$ref": "#/definitions/AtlasRelationshipEndDef",
          "description": "The relationshipEndDef represents an end of the relationship. The end of the\nrelationship is defined by a type, an\nattribute name, cardinality and whether\nit  is the container end of the relationship."
        },
        "relationshipCategory": {
          "$ref": "#/definitions/RelationshipCategory",
          "description": "The Relationship category determines the style of relationship around\ncontainment and lifecycle.\nUML terminology is used for the values.\nASSOCIATION is a relationship with no containment. \nCOMPOSITION and AGGREGATION are containment relationships.\nThe difference being in the lifecycles of the container and its children. \nIn the COMPOSITION case, the children cannot exist without the container.\nFor AGGREGATION, the life cycles of the container and children are totally independent."
        },
        "relationshipLabel": {
          "type": "string",
          "description": "The label of the relationship."
        }
      }
    },
    "AtlasRelationshipEndDef": {
      "type": "object",
      "description": "The relationshipEndDef represents an end of the relationship. The end of the\nrelationship is defined by a type, an\nattribute name, cardinality and whether\nit  is the container end of the relationship.",
      "properties": {
        "cardinality": {
          "$ref": "#/definitions/CardinalityValue",
          "description": "single-valued attribute or multi-valued attribute."
        },
        "description": {
          "type": "string",
          "description": "The description of the relationship end definition."
        },
        "isContainer": {
          "type": "boolean",
          "description": "Determines if it is container."
        },
        "isLegacyAttribute": {
          "type": "boolean",
          "description": "Determines if it is a legacy attribute."
        },
        "name": {
          "type": "string",
          "description": "The name of the relationship end definition."
        },
        "type": {
          "type": "string",
          "description": "The type of the relationship end."
        }
      }
    },
    "AtlasRelationshipWithExtInfo": {
      "type": "object",
      "description": "The relationship with extended information.",
      "properties": {
        "referredEntities": {
          "type": "object",
          "description": "The referred entity header.",
          "additionalProperties": {
            "$ref": "#/definitions/AtlasEntityHeader"
          }
        },
        "relationship": {
          "$ref": "#/definitions/AtlasRelationship",
          "description": "Atlas relationship instance."
        }
      }
    },
    "AtlasStruct": {
      "type": "object",
      "description": "Captures details of struct contents. Not instantiated directly, used only via\nAtlasEntity, AtlasClassification.",
      "properties": {
        "attributes": {
          "type": "object",
          "description": "The attributes of the struct.",
          "additionalProperties": {}
        },
        "typeName": {
          "type": "string",
          "description": "The name of the type."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        }
      }
    },
    "AtlasStructDef": {
      "type": "object",
      "description": "class that captures details of a struct-type.",
      "properties": {
        "category": {
          "$ref": "#/definitions/TypeCategory",
          "description": "The enum of type category."
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The created time of the record."
        },
        "createdBy": {
          "type": "string",
          "description": "The user who created the record."
        },
        "dateFormatter": {
          "$ref": "#/definitions/DateFormat",
          "description": "The date format."
        },
        "description": {
          "type": "string",
          "description": "The description of the type definition."
        },
        "guid": {
          "type": "string",
          "description": "The GUID of the type definition."
        },
        "name": {
          "type": "string",
          "description": "The name of the type definition."
        },
        "options": {
          "type": "object",
          "description": "The options for the type definition.",
          "additionalProperties": {
            "type": "string"
          }
        },
        "serviceType": {
          "type": "string",
          "description": "The service type."
        },
        "typeVersion": {
          "type": "string",
          "description": "The version of the type."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The update time of the record."
        },
        "updatedBy": {
          "type": "string",
          "description": "The user who updated the record."
        },
        "version": {
          "type": "integer",
          "format": "int64",
          "description": "The version of the record."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "attributeDefs": {
          "type": "array",
          "description": "An array of attribute definitions.",
          "items": {
            "$ref": "#/definitions/AtlasAttributeDef"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "AtlasTermAssignmentHeader": {
      "type": "object",
      "description": "The header for term assignment.",
      "properties": {
        "confidence": {
          "type": "integer",
          "format": "int32",
          "description": "The confidence of the term assignment."
        },
        "createdBy": {
          "type": "string",
          "description": "The user who created the record."
        },
        "description": {
          "type": "string",
          "description": "The description of the term assignment."
        },
        "displayText": {
          "type": "string",
          "description": "The display text."
        },
        "expression": {
          "type": "string",
          "description": "The expression of the term assignment."
        },
        "relationGuid": {
          "$ref": "#/definitions/Azure.Core.uuid",
          "description": "The GUID of the relationship."
        },
        "status": {
          "$ref": "#/definitions/AtlasTermAssignmentStatus",
          "description": "The status of terms assignment."
        },
        "steward": {
          "type": "string",
          "description": "The steward of the term."
        },
        "termGuid": {
          "$ref": "#/definitions/Azure.Core.uuid",
          "description": "The GUID of the term."
        }
      }
    },
    "AtlasTermAssignmentStatus": {
      "type": "string",
      "description": "Status for term assignment",
      "enum": [
        "DISCOVERED",
        "PROPOSED",
        "IMPORTED",
        "VALIDATED",
        "DEPRECATED",
        "OBSOLETE",
        "OTHER"
      ],
      "x-ms-enum": {
        "name": "AtlasTermAssignmentStatus",
        "modelAsString": true,
        "values": [
          {
            "name": "Discovered",
            "value": "DISCOVERED",
            "description": "The status is discovered."
          },
          {
            "name": "Proposed",
            "value": "PROPOSED",
            "description": "The status is proposed."
          },
          {
            "name": "Imported",
            "value": "IMPORTED",
            "description": "The status is imported."
          },
          {
            "name": "Validated",
            "value": "VALIDATED",
            "description": "The status is validated."
          },
          {
            "name": "Deprecated",
            "value": "DEPRECATED",
            "description": "The status is deprecated."
          },
          {
            "name": "Obsolete",
            "value": "OBSOLETE",
            "description": "The status is obsolete."
          },
          {
            "name": "Other",
            "value": "OTHER",
            "description": "Other status."
          }
        ]
      }
    },
    "AtlasTermCategorizationHeader": {
      "type": "object",
      "description": "The basic information for term categorization.",
      "properties": {
        "categoryGuid": {
          "$ref": "#/definitions/Azure.Core.uuid",
          "description": "The GUID of the category."
        },
        "description": {
          "type": "string",
          "description": "The description of the record."
        },
        "displayText": {
          "type": "string",
          "description": "The display text."
        },
        "relationGuid": {
          "$ref": "#/definitions/Azure.Core.uuid",
          "description": "The GUID of the relationship."
        },
        "status": {
          "$ref": "#/definitions/AtlasTermRelationshipStatus",
          "description": "The status of term relationship."
        }
      }
    },
    "AtlasTermRelationshipStatus": {
      "type": "string",
      "description": "Status for atlas term relationship",
      "enum": [
        "DRAFT",
        "ACTIVE",
        "DEPRECATED",
        "OBSOLETE",
        "OTHER"
      ],
      "x-ms-enum": {
        "name": "AtlasTermRelationshipStatus",
        "modelAsString": true,
        "values": [
          {
            "name": "Draft",
            "value": "DRAFT",
            "description": "draft"
          },
          {
            "name": "Active",
            "value": "ACTIVE",
            "description": "active"
          },
          {
            "name": "Deprecated",
            "value": "DEPRECATED",
            "description": "deprecated"
          },
          {
            "name": "Obsolete",
            "value": "OBSOLETE",
            "description": "obsolete"
          },
          {
            "name": "Other",
            "value": "OTHER",
            "description": "other"
          }
        ]
      }
    },
    "AtlasTypeDef": {
      "type": "object",
      "description": "The definitions of type.",
      "properties": {
        "category": {
          "$ref": "#/definitions/TypeCategory",
          "description": "The enum of type category."
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The created time of the record."
        },
        "createdBy": {
          "type": "string",
          "description": "The user who created the record."
        },
        "dateFormatter": {
          "$ref": "#/definitions/DateFormat",
          "description": "The date format."
        },
        "description": {
          "type": "string",
          "description": "The description of the type definition."
        },
        "guid": {
          "type": "string",
          "description": "The GUID of the type definition."
        },
        "name": {
          "type": "string",
          "description": "The name of the type definition."
        },
        "options": {
          "type": "object",
          "description": "The options for the type definition.",
          "additionalProperties": {
            "type": "string"
          }
        },
        "serviceType": {
          "type": "string",
          "description": "The service type."
        },
        "typeVersion": {
          "type": "string",
          "description": "The version of the type."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The update time of the record."
        },
        "updatedBy": {
          "type": "string",
          "description": "The user who updated the record."
        },
        "version": {
          "type": "integer",
          "format": "int64",
          "description": "The version of the record."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "entityTypes": {
          "type": "array",
          "description": "Specifying a list of entityType names in the classificationDef, ensures that\nclassifications can\nonly be applied to those entityTypes.\n\nAny subtypes of the entity types inherit the restriction.\n\nAny classificationDef subtypes inherit the parents entityTypes restrictions.\n\nAny classificationDef subtypes can further restrict the parents entityTypes\nrestrictions by specifying a subset of the entityTypes.\n\nAn empty entityTypes list when there are no parent restrictions means there are no\nrestrictions.\n\nAn empty entityTypes list when there are parent\nrestrictions means that the subtype picks up the parents\nrestrictions.\n\nIf a list of entityTypes are supplied, where one inherits\nfrom another, this will be rejected. This should encourage cleaner\nclassificationsDefs.\n",
          "items": {
            "type": "string"
          }
        },
        "subTypes": {
          "type": "array",
          "description": "An array of sub types.",
          "items": {
            "type": "string"
          }
        },
        "superTypes": {
          "type": "array",
          "description": "An array of super types.",
          "items": {
            "type": "string"
          }
        },
        "relationshipAttributeDefs": {
          "type": "array",
          "description": "An array of relationship attributes.",
          "items": {
            "$ref": "#/definitions/AtlasRelationshipAttributeDef"
          },
          "x-ms-identifiers": []
        },
        "defaultValue": {
          "type": "string",
          "description": "The default value."
        },
        "elementDefs": {
          "type": "array",
          "description": "An array of enum element definitions.",
          "items": {
            "$ref": "#/definitions/AtlasEnumElementDef"
          },
          "x-ms-identifiers": []
        },
        "endDef1": {
          "$ref": "#/definitions/AtlasRelationshipEndDef",
          "description": "The relationshipEndDef represents an end of the relationship. The end of the\nrelationship is defined by a type, an\nattribute name, cardinality and whether\nit  is the container end of the relationship."
        },
        "endDef2": {
          "$ref": "#/definitions/AtlasRelationshipEndDef",
          "description": "The relationshipEndDef represents an end of the relationship. The end of the\nrelationship is defined by a type, an\nattribute name, cardinality and whether\nit  is the container end of the relationship."
        },
        "relationshipCategory": {
          "$ref": "#/definitions/RelationshipCategory",
          "description": "The Relationship category determines the style of relationship around\ncontainment and lifecycle.\nUML terminology is used for the values.\n\nASSOCIATION is a relationship with no containment. \nCOMPOSITION and AGGREGATION are containment relationships.\n\nThe difference being in the lifecycles of the container and its children. \nIn the COMPOSITION case, the children cannot exist without the container. \nFor AGGREGATION, the life cycles of the container and children are totally independent."
        },
        "relationshipLabel": {
          "type": "string",
          "description": "The label of the relationship."
        },
        "attributeDefs": {
          "type": "array",
          "description": "An array of attribute definitions.",
          "items": {
            "$ref": "#/definitions/AtlasAttributeDef"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "AtlasTypeDefHeader": {
      "type": "object",
      "description": "The basic information of the type definition.",
      "properties": {
        "category": {
          "$ref": "#/definitions/TypeCategory",
          "description": "The enum of type category."
        },
        "guid": {
          "type": "string",
          "description": "The GUID of the type definition."
        },
        "name": {
          "type": "string",
          "description": "The name of the type definition."
        }
      }
    },
    "AtlasTypesDef": {
      "type": "object",
      "description": "The definitions of types.",
      "properties": {
        "businessMetadataDefs": {
          "type": "array",
          "description": "businessMetadataDefs",
          "items": {
            "$ref": "#/definitions/AtlasBusinessMetadataDef"
          },
          "x-ms-identifiers": []
        },
        "classificationDefs": {
          "type": "array",
          "description": "An array of classification definitions.",
          "items": {
            "$ref": "#/definitions/AtlasClassificationDef"
          },
          "x-ms-identifiers": []
        },
        "entityDefs": {
          "type": "array",
          "description": "An array of entity definitions.",
          "items": {
            "$ref": "#/definitions/AtlasEntityDef"
          },
          "x-ms-identifiers": []
        },
        "enumDefs": {
          "type": "array",
          "description": "An array of enum definitions.",
          "items": {
            "$ref": "#/definitions/AtlasEnumDef"
          },
          "x-ms-identifiers": []
        },
        "relationshipDefs": {
          "type": "array",
          "description": "An array of relationship definitions.",
          "items": {
            "$ref": "#/definitions/AtlasRelationshipDef"
          },
          "x-ms-identifiers": []
        },
        "structDefs": {
          "type": "array",
          "description": "An array of struct definitions.",
          "items": {
            "$ref": "#/definitions/AtlasStructDef"
          },
          "x-ms-identifiers": []
        },
        "termTemplateDefs": {
          "type": "array",
          "description": "An array of term template definitions.",
          "items": {
            "$ref": "#/definitions/TermTemplateDef"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "AutoCompleteOptions": {
      "type": "object",
      "description": "The payload of autocomplete request.",
      "properties": {
        "keywords": {
          "type": "string",
          "description": "The keywords applied to all fields that support autocomplete operation. It must\nbe at least 1 character, and no more than 100 characters."
        },
        "limit": {
          "type": "integer",
          "format": "int32",
          "description": "The number of autocomplete results we hope to return. The default value is 50.\nThe value must be a number between 1 and 100."
        },
        "filter": {
          "description": "The filter for the autocomplete request."
        }
      }
    },
    "AutoCompleteResult": {
      "type": "object",
      "description": "The result of the autocomplete request.",
      "properties": {
        "value": {
          "type": "array",
          "description": "The result value",
          "items": {
            "$ref": "#/definitions/AutoCompleteResultValue"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "AutoCompleteResultValue": {
      "type": "object",
      "description": "The value item of the autocomplete suggest.",
      "properties": {
        "text": {
          "type": "string",
          "description": "The completed term or phrase."
        },
        "queryPlusText": {
          "type": "string",
          "description": "The completed search query text."
        }
      }
    },
    "Azure.Core.uuid": {
      "type": "string",
      "format": "uuid",
      "description": "Universally Unique Identifier"
    },
    "BulkImportResult": {
      "type": "object",
      "description": "Bulk import result",
      "properties": {
        "failedImportInfoList": {
          "type": "array",
          "description": "failed importInfoList",
          "items": {
            "$ref": "#/definitions/ImportInfo"
          },
          "x-ms-identifiers": []
        },
        "successImportInfoList": {
          "type": "array",
          "description": "successful importInfoList",
          "items": {
            "$ref": "#/definitions/ImportInfo"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "CardinalityValue": {
      "type": "string",
      "description": "Cardinality",
      "enum": [
        "SINGLE",
        "LIST",
        "SET"
      ],
      "x-ms-enum": {
        "name": "CardinalityValue",
        "modelAsString": true,
        "values": [
          {
            "name": "Single",
            "value": "SINGLE",
            "description": "single"
          },
          {
            "name": "List",
            "value": "LIST",
            "description": "list"
          },
          {
            "name": "Set",
            "value": "SET",
            "description": "set"
          }
        ]
      }
    },
    "ClassificationAssociateOptions": {
      "type": "object",
      "description": "The request payload for classification association.",
      "properties": {
        "classification": {
          "$ref": "#/definitions/AtlasClassification",
          "description": "An instance of a classification; it doesn't have an identity, this object\nexists only when associated with an entity."
        },
        "entityGuids": {
          "type": "array",
          "description": "The GUID of the entity.",
          "items": {
            "type": "string"
          }
        }
      }
    },
    "ContactInfo": {
      "type": "object",
      "description": "ContactInfo",
      "properties": {
        "id": {
          "type": "string",
          "description": "Azure Active Directory object Id."
        },
        "info": {
          "type": "string",
          "description": "additional information to describe this contact."
        }
      }
    },
    "ContactSearchResultValue": {
      "type": "object",
      "description": "The contact in the search and suggest result.",
      "properties": {
        "id": {
          "type": "string",
          "description": "The GUID of the contact."
        },
        "info": {
          "type": "string",
          "description": "The description of the contact."
        },
        "contactType": {
          "type": "string",
          "description": "The type of the contact. It can be Expert or Owner for an entity. It can be\nExpert or Steward for a glossary term."
        }
      }
    },
    "DateFormat": {
      "type": "object",
      "description": "The date format.",
      "properties": {
        "availableLocales": {
          "type": "array",
          "description": "An array of available locales.",
          "items": {
            "type": "string"
          }
        },
        "calendar": {
          "type": "number",
          "format": "float",
          "description": "Calendar"
        },
        "dateInstance": {
          "$ref": "#/definitions/DateFormat",
          "description": "The date format."
        },
        "dateTimeInstance": {
          "$ref": "#/definitions/DateFormat",
          "description": "The date format."
        },
        "instance": {
          "$ref": "#/definitions/DateFormat",
          "description": "The date format."
        },
        "lenient": {
          "type": "boolean",
          "description": "Determines the leniency of the date format."
        },
        "numberFormat": {
          "$ref": "#/definitions/NumberFormat",
          "description": "The number format."
        },
        "timeInstance": {
          "$ref": "#/definitions/DateFormat",
          "description": "The date format."
        },
        "timeZone": {
          "$ref": "#/definitions/TimeZone",
          "description": "The timezone information."
        }
      }
    },
    "EntityMutationResult": {
      "type": "object",
      "description": "The mutation response result of entity.",
      "properties": {
        "guidAssignments": {
          "type": "object",
          "description": "A map of GUID assignments with entities.",
          "additionalProperties": {
            "type": "string"
          }
        },
        "mutatedEntities": {
          "type": "object",
          "description": "The entity headers of mutated entities.",
          "additionalProperties": {
            "items": {
              "$ref": "#/definitions/AtlasEntityHeader"
            },
            "type": "array",
            "x-ms-identifiers": []
          }
        },
        "partialUpdatedEntities": {
          "type": "array",
          "description": "An array of entity headers that partially updated.",
          "items": {
            "$ref": "#/definitions/AtlasEntityHeader"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "EntityStatus": {
      "type": "string",
      "description": "Status - can be active or deleted",
      "enum": [
        "ACTIVE",
        "DELETED"
      ],
      "x-ms-enum": {
        "name": "EntityStatus",
        "modelAsString": true,
        "values": [
          {
            "name": "Active",
            "value": "ACTIVE",
            "description": "The status is active."
          },
          {
            "name": "Deleted",
            "value": "DELETED",
            "description": "The status is deleted."
          }
        ]
      }
    },
    "ImportInfo": {
      "type": "object",
      "description": "ImportInfo",
      "properties": {
        "childObjectName": {
          "type": "string",
          "description": "childObjectName"
        },
        "importStatus": {
          "$ref": "#/definitions/ImportStatus",
          "description": "importStatus"
        },
        "parentObjectName": {
          "type": "string",
          "description": "parentObjectName"
        },
        "remarks": {
          "type": "string",
          "description": "remarks"
        }
      }
    },
    "ImportStatus": {
      "type": "string",
      "description": "Status for import",
      "enum": [
        "SUCCESS",
        "FAILED"
      ],
      "x-ms-enum": {
        "name": "ImportStatus",
        "modelAsString": true,
        "values": [
          {
            "name": "Success",
            "value": "SUCCESS",
            "description": "Success"
          },
          {
            "name": "Failed",
            "value": "FAILED",
            "description": "Failed"
          }
        ]
      }
    },
    "LineageDirection": {
      "type": "string",
      "description": "Lineage direction",
      "enum": [
        "INPUT",
        "OUTPUT",
        "BOTH"
      ],
      "x-ms-enum": {
        "name": "LineageDirection",
        "modelAsString": true,
        "values": [
          {
            "name": "Input",
            "value": "INPUT",
            "description": "input"
          },
          {
            "name": "Output",
            "value": "OUTPUT",
            "description": "output"
          },
          {
            "name": "Both",
            "value": "BOTH",
            "description": "both"
          }
        ]
      }
    },
    "LineageRelation": {
      "type": "object",
      "description": "The lineage relation with GUID of the from and to entity.",
      "properties": {
        "fromEntityId": {
          "type": "string",
          "description": "The GUID of from-entity."
        },
        "relationshipId": {
          "type": "string",
          "description": "The GUID of relationship."
        },
        "toEntityId": {
          "type": "string",
          "description": "The GUID of to-entity."
        }
      }
    },
    "MoveEntitiesOptions": {
      "type": "object",
      "description": "MoveEntitiesOptions",
      "properties": {
        "entityGuids": {
          "type": "array",
          "description": "An array of entity guids to be moved to target collection.",
          "items": {
            "type": "string"
          }
        }
      }
    },
    "NumberFormat": {
      "type": "object",
      "description": "The number format.",
      "properties": {
        "availableLocales": {
          "type": "array",
          "description": "The number format.",
          "items": {
            "type": "string"
          }
        },
        "currency": {
          "type": "string",
          "description": "The currency."
        },
        "currencyInstance": {
          "$ref": "#/definitions/NumberFormat",
          "description": "The number format."
        },
        "groupingUsed": {
          "type": "boolean",
          "description": "Determines if grouping is used."
        },
        "instance": {
          "$ref": "#/definitions/NumberFormat",
          "description": "The number format."
        },
        "integerInstance": {
          "$ref": "#/definitions/NumberFormat",
          "description": "The number format."
        },
        "maximumFractionDigits": {
          "type": "integer",
          "format": "int32",
          "description": "The maximum of fraction digits."
        },
        "maximumIntegerDigits": {
          "type": "integer",
          "format": "int32",
          "description": "The maximum of integer digits."
        },
        "minimumFractionDigits": {
          "type": "integer",
          "format": "int32",
          "description": "The minimum of fraction digits."
        },
        "minimumIntegerDigits": {
          "type": "integer",
          "format": "int32",
          "description": "The minimum of integer digits."
        },
        "numberInstance": {
          "$ref": "#/definitions/NumberFormat",
          "description": "The number format."
        },
        "parseIntegerOnly": {
          "type": "boolean",
          "description": "Determines if only integer is parsed."
        },
        "percentInstance": {
          "$ref": "#/definitions/NumberFormat",
          "description": "The number format."
        },
        "roundingMode": {
          "$ref": "#/definitions/RoundingMode",
          "description": "The enum of rounding mode."
        }
      }
    },
    "ParentRelation": {
      "type": "object",
      "description": "The lineage parents relation with GUID of the parent entity and to child entity.",
      "properties": {
        "childEntityId": {
          "type": "string",
          "description": "The GUID of child entity."
        },
        "relationshipId": {
          "type": "string",
          "description": "The GUID of relationship."
        },
        "parentEntityId": {
          "type": "string",
          "description": "The GUID of parent entity."
        }
      }
    },
    "PurviewObjectId": {
      "type": "object",
      "description": "PurviewObjectId",
      "properties": {
        "guid": {
          "type": "string",
          "description": "The GUID of the object."
        },
        "typeName": {
          "type": "string",
          "description": "The name of the type."
        },
        "uniqueAttributes": {
          "type": "object",
          "description": "The unique attributes of the object.",
          "additionalProperties": {}
        },
        "name": {
          "type": "string",
          "description": "Name"
        },
        "displayText": {
          "type": "string",
          "description": "Display text"
        },
        "itemPath": {
          "type": "string",
          "description": "Item path"
        },
        "resourceId": {
          "type": "string",
          "description": "Resource Id"
        },
        "properties": {
          "type": "object",
          "description": "Dictionary of <any>",
          "additionalProperties": {}
        }
      }
    },
    "QueryOptions": {
      "type": "object",
      "description": "The search query of advanced search request.",
      "properties": {
        "keywords": {
          "type": "string",
          "description": "The keywords applied to all searchable fields."
        },
        "limit": {
          "type": "integer",
          "format": "int32",
          "description": "The limit of the number of the search result. default value is 50; maximum\nvalue is 1000."
        },
        "continuationToken": {
          "type": "string",
          "description": "The token used to get next batch of data. Default 'Null' to get the first\nbatch, and will return new token in each response unless there's no more data."
        },
        "orderby": {
          "type": "array",
          "description": "The sort order of search results, can specify multiple fields.",
          "items": {}
        },
        "filter": {
          "description": "The filter for the search. See examples for the usage of supported filters."
        },
        "facets": {
          "type": "array",
          "description": "The facets for search. See examples for the usage of supported facets.",
          "items": {
            "$ref": "#/definitions/SearchFacetItem"
          },
          "x-ms-identifiers": []
        },
        "taxonomySetting": {
          "$ref": "#/definitions/SearchTaxonomySetting",
          "description": "The taxonomy setting for search."
        }
      }
    },
    "QueryResult": {
      "type": "object",
      "description": "The result of the search result.",
      "properties": {
        "@search.count": {
          "type": "integer",
          "format": "int32",
          "description": "The total number of search results (not the number of documents in a single\npage).",
          "x-ms-client-name": "searchCount"
        },
        "@search.count.approximate": {
          "type": "boolean",
          "description": "'True' if the '@search.count' is an approximate value and vise versa.",
          "x-ms-client-name": "searchCountApproximate"
        },
        "continuationToken": {
          "type": "string",
          "description": "The token used to get next batch of data. Absent if there's no more data."
        },
        "@search.facets": {
          "$ref": "#/definitions/SearchFacetResultValue",
          "description": "A facet list that consists of index fields assetType ,classification,\ncontactId, and label. When the facet is specified in the request, the value of\nthe facet is returned as an element of @search.facets.",
          "x-ms-client-name": "searchFacets"
        },
        "value": {
          "type": "array",
          "description": "Search result value",
          "items": {
            "$ref": "#/definitions/SearchResultValue"
          }
        }
      }
    },
    "RelationshipCategory": {
      "type": "string",
      "description": "Relationship Category",
      "enum": [
        "ASSOCIATION",
        "AGGREGATION",
        "COMPOSITION"
      ],
      "x-ms-enum": {
        "name": "RelationshipCategory",
        "modelAsString": true,
        "values": [
          {
            "name": "Association",
            "value": "ASSOCIATION",
            "description": "association"
          },
          {
            "name": "Aggregation",
            "value": "AGGREGATION",
            "description": "aggregation"
          },
          {
            "name": "Composition",
            "value": "COMPOSITION",
            "description": "composition"
          }
        ]
      }
    },
    "ResourceLink": {
      "type": "object",
      "description": "ResourceLink",
      "properties": {
        "displayName": {
          "type": "string",
          "description": "Display name for url."
        },
        "url": {
          "type": "string",
          "description": "web url. http or https"
        }
      }
    },
    "RoundingMode": {
      "type": "string",
      "description": "Rounding Mode",
      "enum": [
        "UP",
        "DOWN",
        "CEILING",
        "FLOOR",
        "HALF_UP",
        "HALF_DOWN",
        "HALF_EVEN",
        "UNNECESSARY"
      ],
      "x-ms-enum": {
        "name": "RoundingMode",
        "modelAsString": true,
        "values": [
          {
            "name": "Up",
            "value": "UP",
            "description": "up"
          },
          {
            "name": "Down",
            "value": "DOWN",
            "description": "down"
          },
          {
            "name": "Ceiling",
            "value": "CEILING",
            "description": "ceiling"
          },
          {
            "name": "Floor",
            "value": "FLOOR",
            "description": "floor"
          },
          {
            "name": "HalfUp",
            "value": "HALF_UP",
            "description": "half up"
          },
          {
            "name": "HalfDown",
            "value": "HALF_DOWN",
            "description": "half down"
          },
          {
            "name": "HalfEven",
            "value": "HALF_EVEN",
            "description": "half even"
          },
          {
            "name": "Unnecessary",
            "value": "UNNECESSARY",
            "description": "unnecessary"
          }
        ]
      }
    },
    "SearchFacetItem": {
      "type": "object",
      "description": "The content of a search facet result item.",
      "properties": {
        "count": {
          "type": "integer",
          "format": "int32",
          "description": "The count of the facet item."
        },
        "facet": {
          "type": "string",
          "description": "The name of the facet item."
        },
        "sort": {
          "$ref": "#/definitions/SearchFacetSort",
          "description": "Define the sorting criteria for items"
        }
      }
    },
    "SearchFacetItemValue": {
      "type": "object",
      "description": "The content of a search facet result item.",
      "properties": {
        "count": {
          "type": "integer",
          "format": "int32",
          "description": "The count of the facet item."
        },
        "value": {
          "type": "string",
          "description": "The name of the facet item."
        }
      }
    },
    "SearchFacetResultValue": {
      "type": "object",
      "description": "A facet list that consists of index fields assetType ,classification,\ncontactId, and label. When the facet is specified in the request, the value of\nthe facet is returned as an element of @search.facets.",
      "properties": {
        "entityType": {
          "type": "array",
          "description": "Entity type",
          "items": {
            "$ref": "#/definitions/SearchFacetItemValue"
          },
          "x-ms-identifiers": []
        },
        "assetType": {
          "type": "array",
          "description": "Asset type",
          "items": {
            "$ref": "#/definitions/SearchFacetItemValue"
          },
          "x-ms-identifiers": []
        },
        "classification": {
          "type": "array",
          "description": "Classification",
          "items": {
            "$ref": "#/definitions/SearchFacetItemValue"
          },
          "x-ms-identifiers": []
        },
        "term": {
          "type": "array",
          "description": "Term",
          "items": {
            "$ref": "#/definitions/SearchFacetItemValue"
          },
          "x-ms-identifiers": []
        },
        "contactId": {
          "type": "array",
          "description": "Contact id",
          "items": {
            "$ref": "#/definitions/SearchFacetItemValue"
          },
          "x-ms-identifiers": []
        },
        "contactType": {
          "type": "array",
          "description": "Contact type",
          "items": {
            "$ref": "#/definitions/SearchFacetItemValue"
          },
          "x-ms-identifiers": []
        },
        "label": {
          "type": "array",
          "description": "Label",
          "items": {
            "$ref": "#/definitions/SearchFacetItemValue"
          },
          "x-ms-identifiers": []
        },
        "glossaryType": {
          "type": "array",
          "description": "Glossary type",
          "items": {
            "$ref": "#/definitions/SearchFacetItemValue"
          },
          "x-ms-identifiers": []
        },
        "termStatus": {
          "type": "array",
          "description": "Term status",
          "items": {
            "$ref": "#/definitions/SearchFacetItemValue"
          },
          "x-ms-identifiers": []
        },
        "termTemplate": {
          "type": "array",
          "description": "Term template",
          "items": {
            "$ref": "#/definitions/SearchFacetItemValue"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "SearchFacetSort": {
      "type": "object",
      "description": "The sorting criteria",
      "properties": {
        "count": {
          "$ref": "#/definitions/SearchSortOrder",
          "description": "Order by count"
        },
        "value": {
          "$ref": "#/definitions/SearchSortOrder",
          "description": "Order by value"
        }
      }
    },
    "SearchHighlights": {
      "type": "object",
      "description": "A highlight list that consists of index fields id ,qualifiedName, name,\ndescription, entityType. When the keyword appears in those fields, the value of\nthe field, attached with emphasis mark, is returned as an element of\n@search.highlights.",
      "properties": {
        "id": {
          "type": "array",
          "description": "Id",
          "items": {
            "type": "string"
          }
        },
        "qualifiedName": {
          "type": "array",
          "description": "Qualified name",
          "items": {
            "type": "string"
          }
        },
        "name": {
          "type": "array",
          "description": "Name",
          "items": {
            "type": "string"
          }
        },
        "description": {
          "type": "array",
          "description": "Description",
          "items": {
            "type": "string"
          }
        },
        "entityType": {
          "type": "array",
          "description": "Entity type",
          "items": {
            "type": "string"
          }
        }
      }
    },
    "SearchResultValue": {
      "type": "object",
      "description": "The value item of the search result.",
      "properties": {
        "@search.score": {
          "type": "number",
          "format": "float",
          "description": "The search score calculated by the search engine. The results are ordered by\nsearch score by default.",
          "x-ms-client-name": "searchScore"
        },
        "@search.highlights": {
          "$ref": "#/definitions/SearchHighlights",
          "description": "A highlight list that consists of index fields id ,qualifiedName, name,\ndescription, entityType. When the keyword appears in those fields, the value of\nthe field, attached with emphasis mark, is returned as an element of\n@search.highlights.",
          "x-ms-client-name": "searchHighlights"
        },
        "objectType": {
          "type": "string",
          "description": "The object type of the record. Object type is the top-level property to\ndistinguish whether a record is an asset or a term."
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The create time of the record. The Unix epoch format."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The last update time of the record. The Unix epoch format."
        },
        "id": {
          "type": "string",
          "description": "The GUID of the record."
        },
        "name": {
          "type": "string",
          "description": "The name of the record."
        },
        "qualifiedName": {
          "type": "string",
          "description": "The qualified name of the record."
        },
        "entityType": {
          "type": "string",
          "description": "The type name of the asset."
        },
        "description": {
          "type": "string",
          "description": "The description of the asset."
        },
        "endorsement": {
          "type": "string",
          "description": "The endorsement of the asset."
        },
        "owner": {
          "type": "string",
          "description": "The owner of the record."
        },
        "classification": {
          "type": "array",
          "description": "The classifications of the record.",
          "items": {
            "type": "string"
          }
        },
        "label": {
          "type": "array",
          "description": "The labels of the asset.",
          "items": {
            "type": "string"
          }
        },
        "term": {
          "type": "array",
          "description": "The terms assigned to the asset.",
          "items": {
            "$ref": "#/definitions/TermSearchResultValue"
          },
          "x-ms-identifiers": []
        },
        "contact": {
          "type": "array",
          "description": "The contacts of the asset.",
          "items": {
            "$ref": "#/definitions/ContactSearchResultValue"
          }
        },
        "assetType": {
          "type": "array",
          "description": "The asset types of the asset.",
          "items": {
            "type": "string"
          }
        },
        "glossaryType": {
          "type": "string",
          "description": "The type name of the term. Could be AtlasGlossary, AtlasGlossaryTerm or\nAtlasGlossaryCategory."
        },
        "glossary": {
          "type": "string",
          "description": "The glossary name of the term."
        },
        "termStatus": {
          "type": "string",
          "description": "The status of the term."
        },
        "termTemplate": {
          "type": "array",
          "description": "The term template names used by the term.",
          "items": {
            "type": "string"
          }
        },
        "longDescription": {
          "type": "string",
          "description": "The definition of the term."
        }
      }
    },
    "SearchSortOrder": {
      "type": "string",
      "description": "Search sort order",
      "enum": [
        "asc",
        "desc"
      ],
      "x-ms-enum": {
        "name": "SearchSortOrder",
        "modelAsString": true,
        "values": [
          {
            "name": "Ascend",
            "value": "asc",
            "description": "Use ascending order for sorting"
          },
          {
            "name": "Descend",
            "value": "desc",
            "description": "Use descending order for sorting"
          }
        ]
      }
    },
    "SearchTaxonomySetting": {
      "type": "object",
      "description": "Taxonomy setting for search request",
      "properties": {
        "assetTypes": {
          "type": "array",
          "description": "Asset types",
          "items": {
            "type": "string"
          }
        },
        "facet": {
          "$ref": "#/definitions/SearchFacetItem",
          "description": "The content of a search facet result item."
        }
      }
    },
    "SortType": {
      "type": "string",
      "description": "Type for sorting",
      "enum": [
        "NONE",
        "ASC",
        "DESC"
      ],
      "x-ms-enum": {
        "name": "SortType",
        "modelAsString": true,
        "values": [
          {
            "name": "None",
            "value": "NONE",
            "description": "No sorting order"
          },
          {
            "name": "Ascend",
            "value": "ASC",
            "description": "Use ascending order for sorting"
          },
          {
            "name": "Descend",
            "value": "DESC",
            "description": "Use descending order for sorting"
          }
        ]
      }
    },
    "StatusAtlasRelationship": {
      "type": "string",
      "description": "Status for atlas relationship",
      "enum": [
        "ACTIVE",
        "DELETED"
      ],
      "x-ms-enum": {
        "name": "StatusAtlasRelationship",
        "modelAsString": true,
        "values": [
          {
            "name": "Active",
            "value": "ACTIVE",
            "description": "active"
          },
          {
            "name": "Deleted",
            "value": "DELETED",
            "description": "deleted"
          }
        ]
      }
    },
    "SuggestOptions": {
      "type": "object",
      "description": "The payload of suggest request.",
      "properties": {
        "keywords": {
          "type": "string",
          "description": "The keywords applied to all fields that support suggest operation. It must be\nat least 1 character, and no more than 100 characters. In the index schema we\ndefined a default suggester which lists all the supported fields and specifies\na search mode."
        },
        "limit": {
          "type": "integer",
          "format": "int32",
          "description": "The number of suggestions we hope to return. The default value is 5. The value\nmust be a number between 1 and 100."
        },
        "filter": {
          "description": "The filter for the search."
        }
      }
    },
    "SuggestResult": {
      "type": "object",
      "description": "The result item of the search suggest.",
      "properties": {
        "value": {
          "type": "array",
          "description": "The result value",
          "items": {
            "$ref": "#/definitions/SuggestResultValue"
          }
        }
      }
    },
    "SuggestResultValue": {
      "type": "object",
      "description": "The value item of the search suggest.",
      "properties": {
        "@search.score": {
          "type": "number",
          "format": "float",
          "description": "The search score calculated by the search engine. The results are ordered by\nsearch score by default.",
          "x-ms-client-name": "searchScore"
        },
        "@search.text": {
          "type": "string",
          "description": "The target text that contains the keyword as prefix. The keyword is wrapped\nwith emphasis mark.",
          "x-ms-client-name": "searchText"
        },
        "objectType": {
          "type": "string",
          "description": "The object type of the record. Object type is the top-level property to\ndistinguish whether a record is an asset or a term."
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The create time of the record. The Unix epoch format."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The last update time of the record. The Unix epoch format."
        },
        "id": {
          "type": "string",
          "description": "The GUID of the record."
        },
        "name": {
          "type": "string",
          "description": "The name of the record."
        },
        "qualifiedName": {
          "type": "string",
          "description": "The qualified name of the record."
        },
        "entityType": {
          "type": "string",
          "description": "The type name of the asset."
        },
        "description": {
          "type": "string",
          "description": "The description of the asset."
        },
        "endorsement": {
          "type": "string",
          "description": "The endorsement of the asset."
        },
        "owner": {
          "type": "string",
          "description": "The owner of the record."
        },
        "classification": {
          "type": "array",
          "description": "The classifications of the record.",
          "items": {
            "type": "string"
          }
        },
        "label": {
          "type": "array",
          "description": "The labels of the asset.",
          "items": {
            "type": "string"
          }
        },
        "term": {
          "type": "array",
          "description": "The terms assigned to the asset.",
          "items": {
            "$ref": "#/definitions/TermSearchResultValue"
          },
          "x-ms-identifiers": []
        },
        "contact": {
          "type": "array",
          "description": "The contacts of the asset.",
          "items": {
            "$ref": "#/definitions/ContactSearchResultValue"
          }
        },
        "assetType": {
          "type": "array",
          "description": "The asset types of the asset.",
          "items": {
            "type": "string"
          }
        },
        "glossaryType": {
          "type": "string",
          "description": "The type name of the term. Could be AtlasGlossary, AtlasGlossaryTerm or\nAtlasGlossaryCategory."
        },
        "glossary": {
          "type": "string",
          "description": "The glossary name of the term."
        },
        "termStatus": {
          "type": "string",
          "description": "The status of the term."
        },
        "termTemplate": {
          "type": "array",
          "description": "The term template names used by the term.",
          "items": {
            "type": "string"
          }
        },
        "longDescription": {
          "type": "string",
          "description": "The definition of the term."
        }
      }
    },
    "TermSearchResultValue": {
      "type": "object",
      "description": "The context.",
      "properties": {
        "name": {
          "type": "string",
          "description": "The name of the term."
        },
        "glossaryName": {
          "type": "string",
          "description": "The name of the glossary which contains the term."
        },
        "guid": {
          "type": "string",
          "description": "The GUID of the term."
        }
      }
    },
    "TermStatus": {
      "type": "string",
      "description": "Status for term",
      "enum": [
        "Draft",
        "Approved",
        "Alert",
        "Expired"
      ],
      "x-ms-enum": {
        "name": "TermStatus",
        "modelAsString": true,
        "values": [
          {
            "name": "Draft",
            "value": "Draft",
            "description": "draft"
          },
          {
            "name": "Approved",
            "value": "Approved",
            "description": "approved"
          },
          {
            "name": "Alert",
            "value": "Alert",
            "description": "alert"
          },
          {
            "name": "Expired",
            "value": "Expired",
            "description": "expired"
          }
        ]
      }
    },
    "TermTemplateDef": {
      "type": "object",
      "description": "Term template definition for glossary term.",
      "properties": {
        "category": {
          "$ref": "#/definitions/TypeCategory",
          "description": "The enum of type category."
        },
        "createTime": {
          "type": "integer",
          "format": "int64",
          "description": "The created time of the record."
        },
        "createdBy": {
          "type": "string",
          "description": "The user who created the record."
        },
        "dateFormatter": {
          "$ref": "#/definitions/DateFormat",
          "description": "The date format."
        },
        "description": {
          "type": "string",
          "description": "The description of the type definition."
        },
        "guid": {
          "type": "string",
          "description": "The GUID of the type definition."
        },
        "name": {
          "type": "string",
          "description": "The name of the type definition."
        },
        "options": {
          "type": "object",
          "description": "The options for the type definition.",
          "additionalProperties": {
            "type": "string"
          }
        },
        "serviceType": {
          "type": "string",
          "description": "The service type."
        },
        "typeVersion": {
          "type": "string",
          "description": "The version of the type."
        },
        "updateTime": {
          "type": "integer",
          "format": "int64",
          "description": "The update time of the record."
        },
        "updatedBy": {
          "type": "string",
          "description": "The user who updated the record."
        },
        "version": {
          "type": "integer",
          "format": "int64",
          "description": "The version of the record."
        },
        "lastModifiedTS": {
          "type": "string",
          "description": "ETag for concurrency control."
        },
        "attributeDefs": {
          "type": "array",
          "description": "An array of attribute definitions.",
          "items": {
            "$ref": "#/definitions/AtlasAttributeDef"
          },
          "x-ms-identifiers": []
        }
      }
    },
    "TimeBoundary": {
      "type": "object",
      "description": "Captures time-boundary details",
      "properties": {
        "endTime": {
          "type": "string",
          "description": "The end of the time boundary."
        },
        "startTime": {
          "type": "string",
          "description": "The start of the time boundary."
        },
        "timeZone": {
          "type": "string",
          "description": "The timezone of the time boundary."
        }
      }
    },
    "TimeZone": {
      "type": "object",
      "description": "The timezone information.",
      "properties": {
        "dstSavings": {
          "type": "integer",
          "format": "int32",
          "description": "The value of the daylight saving time."
        },
        "id": {
          "type": "string",
          "description": "The ID of the timezone."
        },
        "availableIds": {
          "type": "array",
          "description": "An array of available IDs.",
          "items": {
            "type": "string"
          }
        },
        "default": {
          "$ref": "#/definitions/TimeZone",
          "description": "The timezone information."
        },
        "displayName": {
          "type": "string",
          "description": "The display name of the timezone."
        },
        "rawOffset": {
          "type": "integer",
          "format": "int32",
          "description": "The raw offset of the timezone."
        }
      }
    },
    "TypeCategory": {
      "type": "string",
      "description": "Type Category",
      "enum": [
        "PRIMITIVE",
        "OBJECT_ID_TYPE",
        "ENUM",
        "STRUCT",
        "CLASSIFICATION",
        "ENTITY",
        "ARRAY",
        "MAP",
        "RELATIONSHIP",
        "TERM_TEMPLATE"
      ],
      "x-ms-enum": {
        "name": "TypeCategory",
        "modelAsString": true,
        "values": [
          {
            "name": "Primitive",
            "value": "PRIMITIVE",
            "description": "primitive"
          },
          {
            "name": "ObjectIdType",
            "value": "OBJECT_ID_TYPE",
            "description": "object id type"
          },
          {
            "name": "Enum",
            "value": "ENUM",
            "description": "enum"
          },
          {
            "name": "Struct",
            "value": "STRUCT",
            "description": "struct"
          },
          {
            "name": "Classification",
            "value": "CLASSIFICATION",
            "description": "classification"
          },
          {
            "name": "Entity",
            "value": "ENTITY",
            "description": "entity"
          },
          {
            "name": "Array",
            "value": "ARRAY",
            "description": "array"
          },
          {
            "name": "Map",
            "value": "MAP",
            "description": "map"
          },
          {
            "name": "Relationship",
            "value": "RELATIONSHIP",
            "description": "relationship"
          },
          {
            "name": "TermTemplate",
            "value": "TERM_TEMPLATE",
            "description": "term template"
          }
        ]
      }
    }
  },
  "parameters": {
    "AtlasApiVersionParameter": {
      "name": "api-version",
      "in": "query",
      "description": "The API version to use for this operation.",
      "required": false,
      "type": "string",
      "minLength": 1,
      "x-ms-parameter-location": "method",
      "x-ms-client-name": "apiVersion"
    },
    "Azure.Core.Foundations.ApiVersionParameter": {
      "name": "api-version",
      "in": "query",
      "description": "The API version to use for this operation.",
      "required": true,
      "type": "string",
      "minLength": 1,
      "x-ms-parameter-location": "method",
      "x-ms-client-name": "apiVersion"
    }
  }
}