You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@atlas.apache.org by ni...@apache.org on 2018/09/18 15:23:20 UTC
[02/33] atlas-website git commit: ATLAS-2868: Updated api
documentation for 1.1.0 release
http://git-wip-us.apache.org/repos/asf/atlas-website/blob/ab60d06f/1.1.0/api/v2/ui/swagger.json
----------------------------------------------------------------------
diff --git a/1.1.0/api/v2/ui/swagger.json b/1.1.0/api/v2/ui/swagger.json
new file mode 100644
index 0000000..4ce3caf
--- /dev/null
+++ b/1.1.0/api/v2/ui/swagger.json
@@ -0,0 +1,3208 @@
+{
+ "swagger": "2.0",
+ "info" : {
+ "description" : "Atlas exposes a variety of REST endpoints to work with types, entities, lineage and data discovery.",
+ "license" : {
+ "url" : "http://www.apache.org/licenses/LICENSE-2.0.txt",
+ "name" : "The Apache Software License, Version 2.0"
+ },
+ "version" : "1.0.0",
+ "title" : "Atlas REST API"
+ },
+ "schemes" : [],
+ "tags" : [
+ {
+ "name" : "DiscoveryREST"
+ ,
+ "description" : "REST interface for data discovery using dsl or full text search."
+ }
+ ,
+ {
+ "name" : "EntityREST"
+ ,
+ "description" : "REST for a single entity."
+ }
+ ,
+ {
+ "name" : "GlossaryREST"
+ }
+ ,
+ {
+ "name" : "LineageREST"
+ ,
+ "description" : "REST interface for an entity's lineage information."
+ }
+ ,
+ {
+ "name" : "RelationshipREST"
+ ,
+ "description" : "REST interface for entity relationships."
+ }
+ ,
+ {
+ "name" : "TypesREST"
+ ,
+ "description" : "REST interface for CRUD operations on type definitions."
+ }
+ ],
+ "definitions" : {
+ "json_AtlasClassification" : {
+ "type" : "object",
+ "title" : "AtlasClassification",
+ "allOf" : [
+ {
+ "$ref" : "#/definitions/json_AtlasStruct"
+ },
+ {
+ "properties" : {
+ "entityGuid" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "string"
+ },
+ "propagate" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "boolean"
+ },
+ "validityPeriods" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "array",
+"items" : {
+ "$ref" : "#/definitions/json_TimeBoundary"
+}
+ }
+ }
+ }
+ ],
+ "example" : {
+ "entityGuid" : "...",
+ "propagate" : true,
+ "validityPeriods" : [ {
+ "startTime" : "...",
+ "endTime" : "...",
+ "timeZone" : "..."
+ }, {
+ "startTime" : "...",
+ "endTime" : "...",
+ "timeZone" : "..."
+ } ],
+ "typeName" : "...",
+ "attributes" : {
+ "property1" : { },
+ "property2" : { }
+ }
+},
+ "description" : "An instance of a classification; it doesn't have an identity, this object exists only when associated with an entity."
+ }
+ ,
+ "json_AtlasStruct" : {
+ "type" : "object",
+ "title" : "AtlasStruct",
+ "properties" : {
+ "typeName" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "string"
+ },
+ "attributes" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "object",
+"additionalProperties" : {
+ "type" : "object"
+}
+ }
+ },
+ "example" : {
+ "typeName" : "...",
+ "attributes" : {
+ "property1" : { },
+ "property2" : { }
+ }
+},
+ "description" : "Captures details of struct contents. Not instantiated directly, used only via AtlasEntity, AtlasClassification."
+ }
+ ,
+ "json_ClassificationAssociateRequest" : {
+ "type" : "object",
+ "title" : "ClassificationAssociateRequest",
+ "properties" : {
+ "classification" : {
+ "readOnly" : false,
+"$ref" : "#/definitions/json_AtlasClassification"
+ },
+ "entityGuids" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "array",
+"items" : {
+ "type" : "string"
+}
+ }
+ },
+ "example" : {
+ "classification" : {
+ "entityGuid" : "...",
+ "propagate" : true,
+ "validityPeriods" : [ {
+ "startTime" : "...",
+ "endTime" : "...",
+ "timeZone" : "..."
+ }, {
+ "startTime" : "...",
+ "endTime" : "...",
+ "timeZone" : "..."
+ } ],
+ "typeName" : "...",
+ "attributes" : {
+ "property1" : { },
+ "property2" : { }
+ }
+ },
+ "entityGuids" : [ "...", "..." ]
+},
+ "description" : ""
+ }
+ ,
+ "json_PList" : {
+ "type" : "object",
+ "title" : "PList",
+ "properties" : {
+ "list" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "array",
+"items" : {
+ "type" : "object"
+}
+ },
+ "startIndex" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "number"
+ },
+ "pageSize" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "number"
+ },
+ "totalCount" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "number"
+ },
+ "sortType" : {
+ "readOnly" : false,
+"$ref" : "#/definitions/json_SortType"
+ },
+ "sortBy" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "string"
+ }
+ },
+ "example" : {
+ "list" : [ { }, { } ],
+ "startIndex" : 12345,
+ "pageSize" : 12345,
+ "totalCount" : 12345,
+ "sortType" : "ASC",
+ "sortBy" : "..."
+},
+ "description" : "Paginated-list, for returning search results."
+ }
+ ,
+ "json_SearchFilter" : {
+ "type" : "object",
+ "title" : "SearchFilter",
+ "properties" : {
+ "params" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "object",
+"additionalProperties" : {
+"type" : "array",
+"items" : {
+ "type" : "string"
+}
+}
+ },
+ "startIndex" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "number"
+ },
+ "maxRows" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "number"
+ },
+ "getCount" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "boolean"
+ },
+ "sortBy" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "string"
+ },
+ "sortType" : {
+ "readOnly" : false,
+"$ref" : "#/definitions/json_SortType"
+ }
+ },
+ "example" : {
+ "params" : {
+ "property1" : [ "...", "..." ],
+ "property2" : [ "...", "..." ]
+ },
+ "startIndex" : 12345,
+ "maxRows" : 12345,
+ "getCount" : true,
+ "sortBy" : "...",
+ "sortType" : "ASC"
+},
+ "description" : "Generic filter, to specify search criteria using name/value pairs."
+ }
+ ,
+ "json_SortType" : {
+ "type" : "string",
+ "title" : "SortType",
+ "enum" : [
+ "NONE",
+ "ASC",
+ "DESC"
+ ],
+ "description" : "to specify whether the result should be sorted? If yes, whether asc or desc."
+ }
+ ,
+ "json_TimeBoundary" : {
+ "type" : "object",
+ "title" : "TimeBoundary",
+ "properties" : {
+ "startTime" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "string"
+ },
+ "endTime" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "string"
+ },
+ "timeZone" : {
+ "readOnly" : false,
+"description" : "",
+"type" : "string"
+ }
+ },
+ "example" : {
+ "startTime" : "...",
+ "endTime" : "...",
+ "timeZone" : "..."
+},
+ "description" : "Captures time-boundary details"
+ }
+ ,
+ "xml_ns0_PList" : {
+ "type" : "object",
+ "xml" : {
+ "name" : "PList",
+ "namespace" : ""
+ },
+ "title" : "PList",
+ "allOf" : [
+ {
+ "properties" : {
+ "list" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "array",
+"items" : {
+ "type" : "object"
+}
+ },
+ "pageSize" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "integer",
+"format" : "int32"
+ },
+ "sortBy" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "string"
+ },
+ "sortType" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"$ref" : "#/definitions/xml_ns0_sortType"
+ },
+ "startIndex" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "integer",
+"format" : "int64"
+ },
+ "totalCount" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "integer",
+"format" : "int64"
+ }
+ }
+ }
+ ],
+ "description" : "Paginated-list, for returning search results."
+ }
+ ,
+ "xml_ns0_searchFilter" : {
+ "type" : "object",
+ "xml" : {
+ "name" : "searchFilter",
+ "namespace" : ""
+ },
+ "title" : "searchFilter",
+ "allOf" : [
+ {
+ "properties" : {
+ "getCount" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "boolean"
+ },
+ "maxRows" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "integer",
+"format" : "int64"
+ },
+ "params" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "object"
+ },
+ "sortBy" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "string"
+ },
+ "sortType" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"$ref" : "#/definitions/xml_ns0_sortType"
+ },
+ "startIndex" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "integer",
+"format" : "int64"
+ }
+ }
+ }
+ ],
+ "description" : "Generic filter, to specify search criteria using name/value pairs."
+ }
+ ,
+ "xml_ns0_sortType" : {
+ "type" : "string",
+ "title" : "sortType",
+ "enum" : [
+ "NONE",
+ "ASC",
+ "DESC"
+ ],
+ "description" : "to specify whether the result should be sorted? If yes, whether asc or desc."
+ }
+ ,
+ "xml_ns0_timeBoundary" : {
+ "type" : "object",
+ "xml" : {
+ "name" : "timeBoundary",
+ "namespace" : ""
+ },
+ "title" : "timeBoundary",
+ "allOf" : [
+ {
+ "properties" : {
+ "endTime" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "string"
+ },
+ "startTime" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "string"
+ },
+ "timeZone" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "string"
+ }
+ }
+ }
+ ],
+ "description" : "Captures time-boundary details"
+ }
+ ,
+ "xml_ns0_atlasClassification" : {
+ "type" : "object",
+ "xml" : {
+ "name" : "atlasClassification",
+ "namespace" : ""
+ },
+ "title" : "atlasClassification",
+ "allOf" : [
+ {
+ "$ref" : "#/definitions/xml_ns0_atlasStruct"
+ },
+ {
+ "properties" : {
+ "entityGuid" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "string"
+ },
+ "propagate" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "boolean"
+ },
+ "validityPeriods" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "array",
+"items" : {
+ "$ref" : "#/definitions/xml_ns0_timeBoundary"
+}
+ }
+ }
+ }
+ ],
+ "description" : "An instance of a classification; it doesn't have an identity, this object exists only when associated with an entity."
+ }
+ ,
+ "xml_ns0_atlasStruct" : {
+ "type" : "object",
+ "xml" : {
+ "name" : "atlasStruct",
+ "namespace" : ""
+ },
+ "title" : "atlasStruct",
+ "allOf" : [
+ {
+ "properties" : {
+ "attributes" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "object"
+ },
+ "typeName" : {
+ "xml" : {
+ "namespace" : ""
+ },
+ "readOnly" : false,
+"description" : "",
+"type" : "string"
+ }
+ }
+ }
+ ],
+ "description" : "Captures details of struct contents. Not instantiated directly, used only via AtlasEntity, AtlasClassification."
+ }
+ },
+ "paths": {
+ "\/v2/entity" : {
+ "post" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Create new entity or update existing entity in Atlas.",
+ "description" : "Create new entity or update existing entity in Atlas.\nExisting entity is matched using its unique guid if supplied or by its unique attributes eg: qualifiedName",
+ "operationId" : "createOrUpdate",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "201" : {
+ "description" : "EntityMutationResponse"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/entity/bulk" : {
+ "delete" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Bulk API to delete list of entities identified by its GUIDs.",
+ "description" : "Bulk API to delete list of entities identified by its GUIDs",
+ "operationId" : "deleteByGuids",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "query",
+ "type" : "array",
+ "items" : {
+ "type" : "string"
+ },
+ "collectionFormat" : "multi",
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : ""
+ }
+ }
+ }
+ ,
+ "get" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Bulk API to retrieve list of entities identified by its GUIDs.",
+ "description" : "Bulk API to retrieve list of entities identified by its GUIDs.",
+ "operationId" : "getByGuids",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "query",
+ "type" : "array",
+ "items" : {
+ "type" : "string"
+ },
+ "collectionFormat" : "multi",
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : ""
+ }
+ }
+ }
+ ,
+ "post" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Bulk API to create new entities or update existing entities in Atlas.",
+ "description" : "Bulk API to create new entities or update existing entities in Atlas.\nExisting entity is matched using its unique guid if supplied or by its unique attributes eg: qualifiedName",
+ "operationId" : "createOrUpdate",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "201" : {
+ "description" : ""
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/entity/bulk/classification" : {
+ "post" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Bulk API to associate a tag to multiple entities.",
+ "description" : "Bulk API to associate a tag to multiple entities",
+ "operationId" : "addClassification",
+ "consumes" : [ "application/json", "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "body",
+ "in" : "body",
+ "schema" : {
+"$ref" : "#/definitions/json_ClassificationAssociateRequest"
+ },
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "201" : {
+ "description" : "Success"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/entity/guid/{guid}" : {
+ "delete" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Delete an entity identified by its GUID.",
+ "description" : "Delete an entity identified by its GUID.",
+ "operationId" : "deleteByGuid",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "GUID for the entity"
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : "EntityMutationResponse"
+ }
+ }
+ }
+ ,
+ "get" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Fetch complete definition of an entity given its GUID.",
+ "description" : "Fetch complete definition of an entity given its GUID.",
+ "operationId" : "getById",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "GUID for the entity"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "AtlasEntity"
+ }
+ }
+ }
+ ,
+ "put" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Entity Partial Update - Add/Update entity attribute identified by its GUID.",
+ "description" : "Entity Partial Update - Add/Update entity attribute identified by its GUID.\nSupports only uprimitive attribute type and entity references.\ndoes not support updation of complex types like arrays, maps\nNull updates are not possible",
+ "operationId" : "partialUpdateEntityAttrByGuid",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : ""
+ },
+ {
+ "name" : "name",
+ "in" : "query",
+ "type" : "string",
+ "description" : ""
+ },
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : ""
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/entity/guid/{guid}/classification/{classificationName}" : {
+ "delete" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Deletes a given classification from an existing entity represented by a guid.",
+ "description" : "Deletes a given classification from an existing entity represented by a guid.",
+ "operationId" : "deleteClassification",
+ "parameters" : [
+ {
+ "name" : "classificationName",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "name of the classifcation"
+ },
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "globally unique identifier for the entity"
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : "Success"
+ }
+ }
+ }
+ ,
+ "get" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Gets the list of classifications for a given entity represented by a guid.",
+ "description" : "Gets the list of classifications for a given entity represented by a guid.",
+ "operationId" : "getClassification",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "classificationName",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : ""
+ },
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "globally unique identifier for the entity"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "classification for the given entity guid"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/entity/guid/{guid}/classifications" : {
+ "get" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Gets the list of classifications for a given entity represented by a guid.",
+ "description" : "Gets the list of classifications for a given entity represented by a guid.",
+ "operationId" : "getClassifications",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "globally unique identifier for the entity"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "a list of classifications for the given entity guid"
+ }
+ }
+ }
+ ,
+ "post" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Adds classifications to an existing entity represented by a guid.",
+ "description" : "Adds classifications to an existing entity represented by a guid.",
+ "operationId" : "addClassifications",
+ "consumes" : [ "application/json", "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "globally unique identifier for the entity"
+ },
+ {
+ "name" : "body",
+ "in" : "body",
+ "schema" : {
+"description" : "",
+"type" : "array",
+"items" : {
+ "$ref" : "#/definitions/json_AtlasClassification"
+}
+ },
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "201" : {
+ "description" : "Success"
+ }
+ }
+ }
+ ,
+ "put" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Updates classifications to an existing entity represented by a guid.",
+ "description" : "Updates classifications to an existing entity represented by a guid.",
+ "operationId" : "updateClassifications",
+ "consumes" : [ "application/xml", "application/json" ],
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "globally unique identifier for the entity"
+ },
+ {
+ "name" : "body",
+ "in" : "body",
+ "schema" : {
+"description" : "",
+"type" : "array",
+"items" : {
+ "$ref" : "#/definitions/json_AtlasClassification"
+}
+ },
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : "Success"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/entity/uniqueAttribute/type/{typeName}" : {
+ "delete" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Delete an entity identified by its type and unique attributes.",
+ "description" : "Delete an entity identified by its type and unique attributes.\n\nIn addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format\n\nattr:<attrName>=<attrValue>\n\nNOTE: The attrName and attrValue should be unique across entities, eg. qualifiedName\n\nThe REST request would look something like this\n\nDELETE /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue",
+ "operationId" : "deleteByUniqueAttribute",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "typeName",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "- entity type to be deleted"
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : "EntityMutationResponse"
+ }
+ }
+ }
+ ,
+ "get" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Fetch complete definition of an entity given its type and unique attribute.",
+ "description" : "Fetch complete definition of an entity given its type and unique attribute.\n\nIn addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format\n\nattr:<attrName>=<attrValue>\n\nNOTE: The attrName and attrValue should be unique across entities, eg. qualifiedName\n\nThe REST request would look something like this\n\nGET /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue",
+ "operationId" : "getByUniqueAttributes",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "typeName",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "AtlasEntityWithExtInfo"
+ }
+ }
+ }
+ ,
+ "put" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Entity Partial Update - Allows a subset of attributes to be updated on\nan entity which is identified by its type and unique attribute eg: Referenceable.",
+ "description" : "Entity Partial Update - Allows a subset of attributes to be updated on\nan entity which is identified by its type and unique attribute eg: Referenceable.qualifiedName.\nNull updates are not possible\n\nIn addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format\n\nattr:<attrName>=<attrValue>\n\nNOTE: The attrName and attrValue should be unique across entities, eg. qualifiedName\n\nThe REST request would look something like this\n\nPUT /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue",
+ "operationId" : "partialUpdateEntityByUniqueAttrs",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "typeName",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : ""
+ },
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : ""
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/entity/uniqueAttribute/type/{typeName}/classification/{classificationName}" : {
+ "delete" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Deletes a given classification from an entity identified by its type and unique attributes.",
+ "description" : "Deletes a given classification from an entity identified by its type and unique attributes.",
+ "operationId" : "deleteClassificationByUniqueAttribute",
+ "parameters" : [
+ {
+ "name" : "classificationName",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "name of the classification"
+ },
+ {
+ "name" : "typeName",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : "Success"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/entity/uniqueAttribute/type/{typeName}/classifications" : {
+ "post" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Adds classification to the entity identified by its type and unique attributes.",
+ "description" : "Adds classification to the entity identified by its type and unique attributes.",
+ "operationId" : "addClassificationsByUniqueAttribute",
+ "consumes" : [ "application/json", "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "typeName",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : ""
+ },
+ {
+ "name" : "body",
+ "in" : "body",
+ "schema" : {
+"description" : "",
+"type" : "array",
+"items" : {
+ "$ref" : "#/definitions/json_AtlasClassification"
+}
+ },
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "201" : {
+ "description" : "Success"
+ }
+ }
+ }
+ ,
+ "put" : {
+ "tags" : [ "EntityREST" ],
+ "summary" : "Updates classification on an entity identified by its type and unique attributes.",
+ "description" : "Updates classification on an entity identified by its type and unique attributes.",
+ "operationId" : "updateClassificationsByUniqueAttribute",
+ "consumes" : [ "application/json", "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "typeName",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : ""
+ },
+ {
+ "name" : "body",
+ "in" : "body",
+ "schema" : {
+"description" : "",
+"type" : "array",
+"items" : {
+ "$ref" : "#/definitions/json_AtlasClassification"
+}
+ },
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : "Success"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/entity/{guid}/audit" : {
+ "get" : {
+ "tags" : [ "EntityREST" ],
+ "description" : "",
+ "operationId" : "getAuditEvents",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : ""
+ },
+ {
+ "name" : "count",
+ "in" : "query",
+ "default" : "100",
+ "type" : "integer",
+ "format" : "int32",
+ "description" : ""
+ },
+ {
+ "name" : "startKey",
+ "in" : "query",
+ "type" : "string",
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : ""
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary" : {
+ "get" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Retrieve all glossaries registered with Atlas.",
+ "description" : "Retrieve all glossaries registered with Atlas",
+ "operationId" : "getGlossaries",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "limit",
+ "in" : "query",
+ "default" : "-1",
+ "type" : "string",
+ "description" : "page size - by default there is no paging"
+ },
+ {
+ "name" : "offset",
+ "in" : "query",
+ "default" : "0",
+ "type" : "string",
+ "description" : "offset for pagination purpose"
+ },
+ {
+ "name" : "sort",
+ "in" : "query",
+ "default" : "ASC",
+ "type" : "string",
+ "description" : "Sort order, ASC (default) or DESC"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "List of existing glossaries fitting the search criteria or empty list if nothing matches"
+ }
+ }
+ }
+ ,
+ "post" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Create a glossary.",
+ "description" : "Create a glossary",
+ "operationId" : "createGlossary",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : "Glossary definition, terms & categories can be anchored to a glossary\nusing the anchor attribute when creating the Term/Category"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If glossary creation was successful"
+ },
+ "400" : {
+ "description" : "If Glossary definition has invalid or missing information"
+ },
+ "409" : {
+ "description" : "If Glossary definition already exists (duplicate qualifiedName)"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/categories" : {
+ "post" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Create glossary category in bulk.",
+ "description" : "Create glossary category in bulk",
+ "operationId" : "createGlossaryCategories",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : "glossary category definitions"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If BULK glossary category creation was successful"
+ },
+ "400" : {
+ "description" : "If ANY Glossary category definition has invalid or missing information"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/category" : {
+ "post" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Create glossary category.",
+ "description" : "Create glossary category",
+ "operationId" : "createGlossaryCategory",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : "glossary category definition, a category must be anchored to a Glossary when creating\nOptionally, terms belonging to the category and the hierarchy can also be defined during creation"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If glossary category creation was successful"
+ },
+ "400" : {
+ "description" : "If Glossary category definition has invalid or missing information"
+ },
+ "409" : {
+ "description" : "If Glossary category already exists (duplicate qualifiedName)"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/category/{categoryGuid}" : {
+ "delete" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Delete a glossary category.",
+ "description" : "Delete a glossary category",
+ "operationId" : "deleteGlossaryCategory",
+ "parameters" : [
+ {
+ "name" : "categoryGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary category"
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : "If glossary category delete was successful"
+ },
+ "404" : {
+ "description" : "If glossary category guid in invalid"
+ }
+ }
+ }
+ ,
+ "get" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Get specific glossary category.",
+ "description" : "Get specific glossary category",
+ "operationId" : "getGlossaryCategory",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "categoryGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary category"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If glossary category exists for given GUID"
+ },
+ "404" : {
+ "description" : "If glossary category GUID is invalid"
+ }
+ }
+ }
+ ,
+ "put" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Update the given glossary category.",
+ "description" : "Update the given glossary category",
+ "operationId" : "updateGlossaryCategory",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "categoryGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary category"
+ },
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : "updated glossary category"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If glossary category partial update was successful"
+ },
+ "404" : {
+ "description" : "If glossary category guid in invalid"
+ },
+ "400" : {
+ "description" : "If Glossary category definition has invalid or missing information"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/category/{categoryGuid}/partial" : {
+ "put" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Partially update the glossary category.",
+ "description" : "Partially update the glossary category",
+ "operationId" : "partialUpdateGlossaryCategory",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "categoryGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary term"
+ },
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : "Map containing keys as attribute names and values as corresponding attribute values"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If glossary category partial update was successful"
+ },
+ "404" : {
+ "description" : "If glossary category guid in invalid"
+ },
+ "400" : {
+ "description" : "If category attributes are invalid"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/category/{categoryGuid}/related" : {
+ "get" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Get all related categories (parent and children).",
+ "description" : "Get all related categories (parent and children)",
+ "operationId" : "getRelatedCategories",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "categoryGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary category"
+ },
+ {
+ "name" : "limit",
+ "in" : "query",
+ "default" : "-1",
+ "type" : "string",
+ "description" : "page size - by default there is no paging"
+ },
+ {
+ "name" : "offset",
+ "in" : "query",
+ "default" : "0",
+ "type" : "string",
+ "description" : "offset for pagination purpose"
+ },
+ {
+ "name" : "sort",
+ "in" : "query",
+ "default" : "ASC",
+ "type" : "string",
+ "description" : "ASC (default) or DESC"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "List of related categories"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/category/{categoryGuid}/terms" : {
+ "get" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Get all terms associated with the specific category.",
+ "description" : "Get all terms associated with the specific category",
+ "operationId" : "getCategoryTerms",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "categoryGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary category"
+ },
+ {
+ "name" : "limit",
+ "in" : "query",
+ "default" : "-1",
+ "type" : "string",
+ "description" : "page size - by default there is no paging"
+ },
+ {
+ "name" : "offset",
+ "in" : "query",
+ "default" : "0",
+ "type" : "string",
+ "description" : "offset for pagination purpose"
+ },
+ {
+ "name" : "sort",
+ "in" : "query",
+ "default" : "ASC",
+ "type" : "string",
+ "description" : "ASC (default) or DESC"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "List of terms for the given category or an empty list"
+ },
+ "404" : {
+ "description" : "If glossary category guid in invalid"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/term" : {
+ "post" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Create a glossary term.",
+ "description" : "Create a glossary term",
+ "operationId" : "createGlossaryTerm",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : "Glossary term definition, a term must be anchored to a Glossary at the time of creation\noptionally it can be categorized as well"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If glossary term creation was successful"
+ },
+ "400" : {
+ "description" : "If Glossary term definition has invalid or missing information"
+ },
+ "409" : {
+ "description" : "If Glossary term already exists (duplicate qualifiedName)"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/term/{termGuid}" : {
+ "delete" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Delete a glossary term.",
+ "description" : "Delete a glossary term",
+ "operationId" : "deleteGlossaryTerm",
+ "parameters" : [
+ {
+ "name" : "termGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary term"
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : "If glossary term delete was successful"
+ },
+ "404" : {
+ "description" : "If glossary term guid in invalid"
+ }
+ }
+ }
+ ,
+ "get" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Get specific glossary term.",
+ "description" : "Get specific glossary term",
+ "operationId" : "getGlossaryTerm",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "termGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary term"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If glossary term exists for given GUID"
+ },
+ "404" : {
+ "description" : "If glossary term GUID is invalid"
+ }
+ }
+ }
+ ,
+ "put" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Update the given glossary term.",
+ "description" : "Update the given glossary term",
+ "operationId" : "updateGlossaryTerm",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "termGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary term"
+ },
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : "updated glossary term"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If glossary term update was successful"
+ },
+ "404" : {
+ "description" : "If glossary term guid in invalid"
+ },
+ "400" : {
+ "description" : "If Glossary temr definition has invalid or missing information"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/term/{termGuid}/partial" : {
+ "put" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Partially update the glossary term.",
+ "description" : "Partially update the glossary term",
+ "operationId" : "partialUpdateGlossaryTerm",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "termGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary term"
+ },
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : "Map containing keys as attribute names and values as corresponding attribute values"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If glossary partial update was successful"
+ },
+ "404" : {
+ "description" : "If glossary term guid in invalid"
+ },
+ "400" : {
+ "description" : "If partial attributes are invalid"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/terms" : {
+ "post" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Create glossary terms in bulk.",
+ "description" : "Create glossary terms in bulk",
+ "operationId" : "createGlossaryTerms",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : "glossary term definitions"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If Bulk glossary terms creation was successful"
+ },
+ "400" : {
+ "description" : "If any glossary term definition has invalid or missing information"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/terms/{termGuid}/assignedEntities" : {
+ "delete" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Remove the term assignment for the given list of entity headers.",
+ "description" : "Remove the term assignment for the given list of entity headers",
+ "operationId" : "removeTermAssignmentFromEntities",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "termGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "Glossary term GUID"
+ },
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : "List of related entity IDs from which the term has to be dissociated"
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : "If glossary term dissociation was successful"
+ },
+ "400" : {
+ "description" : "If ANY of the entity header is invalid"
+ },
+ "404" : {
+ "description" : "If glossary term guid in invalid"
+ }
+ }
+ }
+ ,
+ "get" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Get all entity headers assigned with the specified term.",
+ "description" : "Get all entity headers assigned with the specified term",
+ "operationId" : "getEntitiesAssignedWithTerm",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "termGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "GUID of the term"
+ },
+ {
+ "name" : "limit",
+ "in" : "query",
+ "default" : "-1",
+ "type" : "string",
+ "description" : "page size - by default there is no paging"
+ },
+ {
+ "name" : "offset",
+ "in" : "query",
+ "default" : "0",
+ "type" : "string",
+ "description" : "offset for pagination purpose"
+ },
+ {
+ "name" : "sort",
+ "in" : "query",
+ "default" : "ASC",
+ "type" : "string",
+ "description" : "ASC (default) or DESC"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "List of entity headers (if any) for the given glossary or an empty list"
+ },
+ "404" : {
+ "description" : "If glossary term guid in invalid"
+ }
+ }
+ }
+ ,
+ "post" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Assign the given term to the provided list of entity headers.",
+ "description" : "Assign the given term to the provided list of entity headers",
+ "operationId" : "assignTermToEntities",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "termGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "Glossary term GUID"
+ },
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : "Related Entity IDs to which the term has to be associated"
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : "If the term assignment was successful"
+ },
+ "400" : {
+ "description" : "If ANY of the entity header is invalid"
+ },
+ "404" : {
+ "description" : "If glossary guid in invalid"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/terms/{termGuid}/related" : {
+ "get" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Get all related terms for a specific term.",
+ "description" : "Get all related terms for a specific term",
+ "operationId" : "getRelatedTerms",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "termGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary term"
+ },
+ {
+ "name" : "limit",
+ "in" : "query",
+ "default" : "-1",
+ "type" : "string",
+ "description" : "page size - by default there is no paging"
+ },
+ {
+ "name" : "offset",
+ "in" : "query",
+ "default" : "0",
+ "type" : "string",
+ "description" : "offset for pagination purpose"
+ },
+ {
+ "name" : "sort",
+ "in" : "query",
+ "default" : "ASC",
+ "type" : "string",
+ "description" : "ASC (default) or DESC"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "List of related glossary terms for the given glossary or an empty list"
+ },
+ "404" : {
+ "description" : "If glossary term guid in invalid"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/{glossaryGuid}" : {
+ "delete" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Delete a glossary.",
+ "description" : "Delete a glossary",
+ "operationId" : "deleteGlossary",
+ "parameters" : [
+ {
+ "name" : "glossaryGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary"
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : "If glossary delete was successful"
+ },
+ "404" : {
+ "description" : "If glossary guid in invalid"
+ }
+ }
+ }
+ ,
+ "get" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Get a specific Glossary.",
+ "description" : "Get a specific Glossary",
+ "operationId" : "getGlossary",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "glossaryGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique glossary identifier"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If glossary with given guid exists"
+ },
+ "404" : {
+ "description" : "If glossary GUID is invalid"
+ }
+ }
+ }
+ ,
+ "put" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Update the given glossary.",
+ "description" : "Update the given glossary",
+ "operationId" : "updateGlossary",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "glossaryGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary"
+ },
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : "Updated glossary definition"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If glossary update was successful"
+ },
+ "404" : {
+ "description" : "If glossary guid in invalid"
+ },
+ "400" : {
+ "description" : "If Glossary definition has invalid or missing information"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/{glossaryGuid}/categories" : {
+ "get" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Get the categories belonging to a specific glossary.",
+ "description" : "Get the categories belonging to a specific glossary",
+ "operationId" : "getGlossaryCategories",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "glossaryGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary term"
+ },
+ {
+ "name" : "limit",
+ "in" : "query",
+ "default" : "-1",
+ "type" : "string",
+ "description" : "page size - by default there is no paging"
+ },
+ {
+ "name" : "offset",
+ "in" : "query",
+ "default" : "0",
+ "type" : "string",
+ "description" : "offset for pagination purpose"
+ },
+ {
+ "name" : "sort",
+ "in" : "query",
+ "default" : "ASC",
+ "type" : "string",
+ "description" : "ASC (default) or DESC"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "List of glossary categories for the given glossary or an empty list"
+ },
+ "404" : {
+ "description" : "If glossary guid in invalid"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/{glossaryGuid}/categories/headers" : {
+ "get" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Get the categories belonging to a specific glossary.",
+ "description" : "Get the categories belonging to a specific glossary",
+ "operationId" : "getGlossaryCategoriesHeaders",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "glossaryGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary term"
+ },
+ {
+ "name" : "limit",
+ "in" : "query",
+ "default" : "-1",
+ "type" : "string",
+ "description" : "page size - by default there is no paging"
+ },
+ {
+ "name" : "offset",
+ "in" : "query",
+ "default" : "0",
+ "type" : "string",
+ "description" : "offset for pagination purpose"
+ },
+ {
+ "name" : "sort",
+ "in" : "query",
+ "default" : "ASC",
+ "type" : "string",
+ "description" : "ASC (default) or DESC"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "List of glossary categories for the given glossary or an empty list"
+ },
+ "404" : {
+ "description" : "If glossary guid in invalid"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/{glossaryGuid}/detailed" : {
+ "get" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Get a specific Glossary.",
+ "description" : "Get a specific Glossary",
+ "operationId" : "getDetailedGlossary",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "glossaryGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique glossary identifier"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If glossary exists for given GUID"
+ },
+ "404" : {
+ "description" : "If glossary GUID is invalid"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/{glossaryGuid}/partial" : {
+ "put" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Partially update the glossary.",
+ "description" : "Partially update the glossary",
+ "operationId" : "partialUpdateGlossary",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "glossaryGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary term"
+ },
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : "Map containing keys as attribute names and values as corresponding attribute values"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If glossary partial update was successful"
+ },
+ "404" : {
+ "description" : "If glossary guid in invalid"
+ },
+ "400" : {
+ "description" : "If partial update parameters are invalid"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/{glossaryGuid}/terms" : {
+ "get" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Get terms belonging to a specific glossary.",
+ "description" : "Get terms belonging to a specific glossary",
+ "operationId" : "getGlossaryTerms",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "glossaryGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary"
+ },
+ {
+ "name" : "limit",
+ "in" : "query",
+ "default" : "-1",
+ "type" : "string",
+ "description" : "page size - by default there is no paging"
+ },
+ {
+ "name" : "offset",
+ "in" : "query",
+ "default" : "0",
+ "type" : "string",
+ "description" : "starting offset for loading terms"
+ },
+ {
+ "name" : "sort",
+ "in" : "query",
+ "default" : "ASC",
+ "type" : "string",
+ "description" : "ASC(default) or DESC"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "List of glossary terms for the given glossary or an empty list"
+ },
+ "404" : {
+ "description" : "If glossary guid in invalid"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/glossary/{glossaryGuid}/terms/headers" : {
+ "get" : {
+ "tags" : [ "GlossaryREST" ],
+ "summary" : "Get term headers belonging to a specific glossary.",
+ "description" : "Get term headers belonging to a specific glossary",
+ "operationId" : "getGlossaryTermHeaders",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "glossaryGuid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "unique identifier for glossary"
+ },
+ {
+ "name" : "limit",
+ "in" : "query",
+ "default" : "-1",
+ "type" : "string",
+ "description" : "page size - by default there is no paging"
+ },
+ {
+ "name" : "offset",
+ "in" : "query",
+ "default" : "0",
+ "type" : "string",
+ "description" : "starting offset for loading terms"
+ },
+ {
+ "name" : "sort",
+ "in" : "query",
+ "default" : "ASC",
+ "type" : "string",
+ "description" : "ASC(default) or DESC"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "List of glossary terms for the given glossary or an empty list"
+ },
+ "404" : {
+ "description" : "If glossary guid in invalid"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/lineage/{guid}" : {
+ "get" : {
+ "tags" : [ "LineageREST" ],
+ "summary" : "Returns lineage info about entity.",
+ "description" : "Returns lineage info about entity.",
+ "operationId" : "getLineageGraph",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "- unique entity id"
+ },
+ {
+ "name" : "depth",
+ "in" : "query",
+ "default" : "3",
+ "type" : "integer",
+ "format" : "int32",
+ "description" : "- number of hops for lineage"
+ },
+ {
+ "name" : "direction",
+ "in" : "query",
+ "default" : "BOTH",
+ "type" : "string",
+ "enum" : ["BOTH", "INPUT", "OUTPUT"],
+ "description" : "- input, output or both"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "If Lineage exists for the given entity"
+ },
+ "400" : {
+ "description" : "Bad query parameters"
+ },
+ "404" : {
+ "description" : "If no lineage is found for the given entity"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/relationship" : {
+ "post" : {
+ "tags" : [ "RelationshipREST" ],
+ "summary" : "Create a new relationship between entities.",
+ "description" : "Create a new relationship between entities.",
+ "operationId" : "create",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "201" : {
+ "description" : ""
+ }
+ }
+ }
+ ,
+ "put" : {
+ "tags" : [ "RelationshipREST" ],
+ "summary" : "Update an existing relationship between entities.",
+ "description" : "Update an existing relationship between entities.",
+ "operationId" : "update",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : ""
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/relationship/guid/{guid}" : {
+ "delete" : {
+ "tags" : [ "RelationshipREST" ],
+ "summary" : "Delete a relationship between entities using guid.",
+ "description" : "Delete a relationship between entities using guid.",
+ "operationId" : "deleteById",
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : "Success"
+ }
+ }
+ }
+ ,
+ "get" : {
+ "tags" : [ "RelationshipREST" ],
+ "summary" : "Get relationship information between entities using guid.",
+ "description" : "Get relationship information between entities using guid.",
+ "operationId" : "getById2",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : ""
+ },
+ {
+ "name" : "extendedInfo",
+ "in" : "query",
+ "default" : "false",
+ "type" : "boolean",
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : ""
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/search/attribute" : {
+ "get" : {
+ "tags" : [ "DiscoveryREST" ],
+ "summary" : "Retrieve data for the specified attribute search query.",
+ "description" : "Retrieve data for the specified attribute search query",
+ "operationId" : "searchUsingAttribute",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "attrName",
+ "in" : "query",
+ "type" : "string",
+ "description" : "Attribute name"
+ },
+ {
+ "name" : "attrValuePrefix",
+ "in" : "query",
+ "type" : "string",
+ "description" : "Attibute value to search on"
+ },
+ {
+ "name" : "limit",
+ "in" : "query",
+ "type" : "integer",
+ "format" : "int32",
+ "description" : "limit the result set to only include the specified number of entries"
+ },
+ {
+ "name" : "offset",
+ "in" : "query",
+ "type" : "integer",
+ "format" : "int32",
+ "description" : "start offset of the result set (useful for pagination)"
+ },
+ {
+ "name" : "typeName",
+ "in" : "query",
+ "type" : "string",
+ "description" : "limit the result to only entities of specified type or its sub-types"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "On successful FullText lookup with some results, might return an empty list if execution succeeded\nwithout any results"
+ },
+ "400" : {
+ "description" : "Invalid wildcard or query parameters"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/search/basic" : {
+ "get" : {
+ "tags" : [ "DiscoveryREST" ],
+ "summary" : "Retrieve data for the specified fulltext query.",
+ "description" : "Retrieve data for the specified fulltext query",
+ "operationId" : "searchUsingBasic",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "classification",
+ "in" : "query",
+ "type" : "string",
+ "description" : "limit the result to only entities tagged with the given classification or or its sub-types"
+ },
+ {
+ "name" : "excludeDeletedEntities",
+ "in" : "query",
+ "type" : "boolean",
+ "description" : ""
+ },
+ {
+ "name" : "limit",
+ "in" : "query",
+ "type" : "integer",
+ "format" : "int32",
+ "description" : "limit the result set to only include the specified number of entries"
+ },
+ {
+ "name" : "offset",
+ "in" : "query",
+ "type" : "integer",
+ "format" : "int32",
+ "description" : "start offset of the result set (useful for pagination)"
+ },
+ {
+ "name" : "query",
+ "in" : "query",
+ "type" : "string",
+ "description" : "Fulltext query"
+ },
+ {
+ "name" : "typeName",
+ "in" : "query",
+ "type" : "string",
+ "description" : "limit the result to only entities of specified type or its sub-types"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "On successful FullText lookup with some results, might return an empty list if execution succeeded\nwithout any results"
+ },
+ "400" : {
+ "description" : "Invalid fulltext or query parameters"
+ }
+ }
+ }
+ ,
+ "post" : {
+ "tags" : [ "DiscoveryREST" ],
+ "summary" : "Attribute based search for entities satisfying the search parameters.",
+ "description" : "Attribute based search for entities satisfying the search parameters",
+ "operationId" : "searchWithParameters",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : "Search parameters"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "On successful search"
+ },
+ "400" : {
+ "description" : "Tag/Entity doesn't exist or Tag/entity filter is present without tag/type name"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/search/dsl" : {
+ "get" : {
+ "tags" : [ "DiscoveryREST" ],
+ "summary" : "Retrieve data for the specified DSL.",
+ "description" : "Retrieve data for the specified DSL",
+ "operationId" : "searchUsingDSL",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "classification",
+ "in" : "query",
+ "type" : "string",
+ "description" : "limit the result to only entities tagged with the given classification or or its sub-types"
+ },
+ {
+ "name" : "limit",
+ "in" : "query",
+ "type" : "integer",
+ "format" : "int32",
+ "description" : "limit the result set to only include the specified number of entries"
+ },
+ {
+ "name" : "offset",
+ "in" : "query",
+ "type" : "integer",
+ "format" : "int32",
+ "description" : "start offset of the result set (useful for pagination)"
+ },
+ {
+ "name" : "query",
+ "in" : "query",
+ "type" : "string",
+ "description" : "DSL query"
+ },
+ {
+ "name" : "typeName",
+ "in" : "query",
+ "type" : "string",
+ "description" : "limit the result to only entities of specified type or its sub-types"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "On successful DSL execution with some results, might return an empty list if execution succeeded\nwithout any results"
+ },
+ "400" : {
+ "description" : "Invalid DSL or query parameters"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/search/fulltext" : {
+ "get" : {
+ "tags" : [ "DiscoveryREST" ],
+ "summary" : "Retrieve data for the specified fulltext query.",
+ "description" : "Retrieve data for the specified fulltext query",
+ "operationId" : "searchUsingFullText",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "excludeDeletedEntities",
+ "in" : "query",
+ "type" : "boolean",
+ "description" : ""
+ },
+ {
+ "name" : "limit",
+ "in" : "query",
+ "type" : "integer",
+ "format" : "int32",
+ "description" : "limit the result set to only include the specified number of entries"
+ },
+ {
+ "name" : "offset",
+ "in" : "query",
+ "type" : "integer",
+ "format" : "int32",
+ "description" : "start offset of the result set (useful for pagination)"
+ },
+ {
+ "name" : "query",
+ "in" : "query",
+ "type" : "string",
+ "description" : "Fulltext query"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "On successful FullText lookup with some results, might return an empty list if execution succeeded\nwithout any results"
+ },
+ "400" : {
+ "description" : "Invalid fulltext or query parameters"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/search/relationship" : {
+ "get" : {
+ "tags" : [ "DiscoveryREST" ],
+ "summary" : "Relationship search to search for related entities satisfying the search parameters.",
+ "description" : "Relationship search to search for related entities satisfying the search parameters",
+ "operationId" : "searchRelatedEntities",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "excludeDeletedEntities",
+ "in" : "query",
+ "type" : "boolean",
+ "description" : ""
+ },
+ {
+ "name" : "guid",
+ "in" : "query",
+ "type" : "string",
+ "description" : "Attribute name"
+ },
+ {
+ "name" : "limit",
+ "in" : "query",
+ "type" : "integer",
+ "format" : "int32",
+ "description" : "limit the result set to only include the specified number of entries"
+ },
+ {
+ "name" : "offset",
+ "in" : "query",
+ "type" : "integer",
+ "format" : "int32",
+ "description" : "start offset of the result set (useful for pagination)"
+ },
+ {
+ "name" : "relation",
+ "in" : "query",
+ "type" : "string",
+ "description" : "relationName"
+ },
+ {
+ "name" : "sortBy",
+ "in" : "query",
+ "type" : "string",
+ "description" : "sort the result using this attribute name, default value is 'name'"
+ },
+ {
+ "name" : "sortOrder",
+ "in" : "query",
+ "type" : "string",
+ "enum" : ["ASCENDING", "DESCENDING"],
+ "description" : "sorting order"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "On successful search"
+ },
+ "400" : {
+ "description" : "guid is not a valid entity type or attributeName is not a valid relationship attribute"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/search/saved" : {
+ "get" : {
+ "tags" : [ "DiscoveryREST" ],
+ "description" : "",
+ "operationId" : "getSavedSearches",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "user",
+ "in" : "query",
+ "type" : "string",
+ "description" : "User for whom the search is retrieved"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "list of all saved searches for given user"
+ }
+ }
+ }
+ ,
+ "post" : {
+ "tags" : [ "DiscoveryREST" ],
+ "description" : "",
+ "operationId" : "addSavedSearch",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "201" : {
+ "description" : "the saved search-object"
+ }
+ }
+ }
+ ,
+ "put" : {
+ "tags" : [ "DiscoveryREST" ],
+ "description" : "",
+ "operationId" : "updateSavedSearch",
+ "consumes" : [ "application/json;charset=UTF-8" ],
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "body",
+ "in" : "body",
+ "type" : "file",
+ "description" : ""
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : "the updated search-object"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/search/saved/execute/guid/{guid}" : {
+ "get" : {
+ "tags" : [ "DiscoveryREST" ],
+ "summary" : "Attribute based search for entities satisfying the search parameters.",
+ "description" : "Attribute based search for entities satisfying the search parameters",
+ "operationId" : "executeSavedSearchByGuid",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "Guid identifying saved search"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "Atlas search result"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/search/saved/execute/{name}" : {
+ "get" : {
+ "tags" : [ "DiscoveryREST" ],
+ "summary" : "Attribute based search for entities satisfying the search parameters.",
+ "description" : "Attribute based search for entities satisfying the search parameters",
+ "operationId" : "executeSavedSearchByName",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "name",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "name of saved-search"
+ },
+ {
+ "name" : "user",
+ "in" : "query",
+ "type" : "string",
+ "description" : "saved-search owner"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "Atlas search result"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/search/saved/{guid}" : {
+ "delete" : {
+ "tags" : [ "DiscoveryREST" ],
+ "description" : "",
+ "operationId" : "deleteSavedSearch",
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "Name of the saved search"
+ }
+ ],
+ "responses" : {
+ "204" : {
+ "description" : "Success"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/search/saved/{name}" : {
+ "get" : {
+ "tags" : [ "DiscoveryREST" ],
+ "description" : "",
+ "operationId" : "getSavedSearch",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "name",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "Name of the saved search"
+ },
+ {
+ "name" : "user",
+ "in" : "query",
+ "type" : "string",
+ "description" : "User for whom the search is retrieved"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : ""
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/types/classificationdef/guid/{guid}" : {
+ "get" : {
+ "tags" : [ "TypesREST" ],
+ "summary" : "Get the classification definition for the given guid.",
+ "description" : "Get the classification definition for the given guid",
+ "operationId" : "getClassificationDefByGuid",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "classification guid"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "On successful lookup of the the classification definition by it's guid"
+ },
+ "404" : {
+ "description" : "On Failed lookup for the given guid"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/types/classificationdef/name/{name}" : {
+ "get" : {
+ "tags" : [ "TypesREST" ],
+ "summary" : "Get the classification definition by it's name (unique).",
+ "description" : "Get the classification definition by it's name (unique)",
+ "operationId" : "getClassificationDefByName",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "name",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "classification name"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "On successful lookup of the the classification definition by it's name"
+ },
+ "404" : {
+ "description" : "On Failed lookup for the given name"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/types/entitydef/guid/{guid}" : {
+ "get" : {
+ "tags" : [ "TypesREST" ],
+ "summary" : "Get the Entity definition for the given guid.",
+ "description" : "Get the Entity definition for the given guid",
+ "operationId" : "getEntityDefByGuid",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "guid",
+ "in" : "path",
+ "required" : true,
+ "type" : "string",
+ "description" : "entity guid"
+ }
+ ],
+ "responses" : {
+ "200" : {
+ "description" : "On successful lookup of the the entity definition by it's guid"
+ },
+ "404" : {
+ "description" : "On Failed lookup for the given guid"
+ }
+ }
+ }
+ }
+ ,
+ "\/v2/types/entitydef/name/{name}" : {
+ "get" : {
+ "tags" : [ "TypesREST" ],
+ "summary" : "Get the entity definition by it's name (unique).",
+ "description" : "Get the entity definition by it's name (unique)",
+ "operationId" : "getEntityDefByName",
+ "produces" : [ "application/json;charset=UTF-8" ],
+ "parameters" : [
+ {
+ "name" : "name",
+ "in" : "path",
+
<TRUNCATED>