GlossaryTerm¶

{
  "$id": "https://open-metadata.org/schema/entity/data/glossaryTerm.json",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "GlossaryTerm",
  "description": "This schema defines te Glossary term entities.",
  "$comment": "@om-entity-type",
  "type": "object",
  "javaType": "org.openmetadata.schema.entity.data.GlossaryTerm",
  "javaInterfaces": ["org.openmetadata.schema.EntityInterface"],

  "definitions": {
    "termReference": {
      "type": "object",
      "properties": {
        "name": {
          "description": "Name that identifies the source of an external glossary term. Example `HealthCare.gov`.",
          "type": "string"
        },
        "endpoint": {
          "description": "Name that identifies the source of an external glossary term. Example `HealthCare.gov`.",
          "type": "string",
          "format": "uri"
        }
      },
      "additionalProperties": false
    }
  },

  "properties": {
    "id": {
      "description": "Unique identifier of a glossary term instance.",
      "$ref": "../../type/basic.json#/definitions/uuid"
    },
    "name": {
      "description": "Preferred name for the glossary term.",
      "$ref": "../../type/basic.json#/definitions/entityName"
    },
    "displayName": {
      "description": "Display Name that identifies this glossary.",
      "type": "string"
    },
    "description": {
      "description": "Description of the glossary term.",
      "$ref": "../../type/basic.json#/definitions/markdown"
    },
    "style": {
      "$ref": "../../type/basic.json#/definitions/style"
    },
    "fullyQualifiedName": {
      "description": "A unique name that identifies a glossary term. It captures name hierarchy of glossary of terms in the form of `glossaryName.parentTerm.childTerm`.",
      "$ref": "../../type/basic.json#/definitions/fullyQualifiedEntityName"
    },
    "synonyms": {
      "description": "Alternate names that are synonyms or near-synonyms for the glossary term.",
      "type": "array",
      "items": {
        "$ref": "../../type/basic.json#/definitions/entityName"
      }
    },
    "glossary": {
      "description": "Glossary that this term belongs to.",
      "$ref": "../../type/entityReference.json"
    },
    "parent": {
      "description": "Parent glossary term that this term is child of. When `null` this term is the root term of the glossary.",
      "$ref": "../../type/entityReference.json"
    },
    "children": {
      "description": "Other glossary terms that are children of this glossary term.",
      "$ref": "../../type/entityReferenceList.json"
    },
    "relatedTerms": {
      "description": "Other glossary terms that are related to this glossary term.",
      "$ref": "../../type/entityReferenceList.json"
    },
    "references": {
      "description": "Link to a reference from an external glossary.",
      "type": "array",
      "items": {
        "$ref": "../../entity/data/glossaryTerm.json#/definitions/termReference"
      }
    },
    "version": {
      "description": "Metadata version of the entity.",
      "$ref": "../../type/entityHistory.json#/definitions/entityVersion"
    },
    "updatedAt": {
      "description": "Last update time corresponding to the new version of the entity in Unix epoch time milliseconds.",
      "$ref": "../../type/basic.json#/definitions/timestamp"
    },
    "updatedBy": {
      "description": "User who made the update.",
      "type": "string"
    },
    "impersonatedBy": {
      "description": "Bot user that performed the action on behalf of the actual user.",
      "$ref": "../../type/basic.json#/definitions/impersonatedBy"
    },
    "href": {
      "description": "Link to the resource corresponding to this entity.",
      "$ref": "../../type/basic.json#/definitions/href"
    },
    "reviewers": {
      "description": "User names of the reviewers for this glossary.",
      "$ref": "../../type/entityReferenceList.json"
    },
    "owners": {
      "description": "Owners of this glossary term.",
      "$ref": "../../type/entityReferenceList.json"
    },
    "usageCount": {
      "description": "Count of how many times this and it's children glossary terms are used as labels.",
      "type": "integer"
    },
    "tags": {
      "description": "Tags associated with this glossary term. These tags captures relationship of a glossary term with a tag automatically. As an example a glossary term 'User.PhoneNumber' might have an associated tag 'PII.Sensitive'. When 'User.Address' is used to label a column in a table, 'PII.Sensitive' label is also applied automatically due to Associated tag relationship.",
      "type": "array",
      "items": {
        "$ref": "../../type/tagLabel.json"
      },
      "default": []
    },
    "changeDescription": {
      "description": "Change that lead to this version of the entity.",
      "$ref": "../../type/entityHistory.json#/definitions/changeDescription"
    },
    "incrementalChangeDescription": {
      "description": "Change that lead to this version of the entity.",
      "$ref": "../../type/entityHistory.json#/definitions/changeDescription"
    },
    "entityStatus": {
      "description": "Approval status of the glossary term.",
      "$ref": "../../type/status.json"
    },
    "deleted": {
      "description": "When `true` indicates the entity has been soft deleted.",
      "type": "boolean",
      "default": false
    },
    "provider": {
      "$ref": "../../type/basic.json#/definitions/providerType"
    },
    "disabled": {
      "description": "System glossary can't be deleted. Use this flag to disable them.",
      "type": "boolean"
    },
    "mutuallyExclusive": {
      "description": "Glossary terms that are children of this term are mutually exclusive. When mutually exclusive is `true` only one term can be used to label an entity from this group. When mutually exclusive is `false`, multiple terms from this group can be used to label an entity.",
      "type": "boolean",
      "default": "false"
    },
    "extension": {
      "description": "Entity extension data with custom attributes added to the entity.",
      "$ref": "../../type/basic.json#/definitions/entityExtension"
    },
    "domains": {
      "description": "Domains the Glossary Term belongs to. When not set, the Glossary TErm inherits the domain from the Glossary it belongs to.",
      "$ref": "../../type/entityReferenceList.json"
    },
    "dataProducts": {
      "description": "List of data products this entity is part of.",
      "$ref": "../../type/entityReferenceList.json"
    },
    "votes": {
      "description": "Votes on the entity.",
      "$ref": "../../type/votes.json"
    },
    "childrenCount": {
      "description": "Count of immediate children glossary terms.",
      "type": "integer"
    }
  },

  "required": ["id", "name", "description", "glossary"],
  "additionalProperties": false
}

{
  "@context": {
    "@vocab": "https://open-metadata.org/schema/",
    "om": "https://open-metadata.org/schema/",
    "skos": "http://www.w3.org/2004/02/skos/core#",
    "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
    "xsd": "http://www.w3.org/2001/XMLSchema#",

    "GlossaryTerm": "om:GlossaryTerm",
    "Concept": "skos:Concept",
    "name": {
      "@id": "om:termName",
      "@type": "xsd:string"
    },
    "fullyQualifiedName": {
      "@id": "om:fullyQualifiedName",
      "@type": "xsd:string"
    },
    "displayName": {
      "@id": "om:displayName",
      "@type": "xsd:string"
    },
    "description": {
      "@id": "om:termDefinition",
      "@type": "xsd:string"
    },
    "definition": {
      "@id": "skos:definition",
      "@type": "xsd:string"
    },
    "synonyms": {
      "@id": "skos:altLabel",
      "@type": "xsd:string",
      "@container": "@set"
    },
    "entityStatus": {
      "@id": "om:entityStatus",
      "@type": "@vocab"
    },
    "glossary": {
      "@id": "skos:inScheme",
      "@type": "@id"
    },
    "parent": {
      "@id": "skos:broader",
      "@type": "@id"
    },
    "children": {
      "@id": "skos:narrower",
      "@type": "@id",
      "@container": "@set"
    },
    "relatedTerms": {
      "@id": "skos:related",
      "@type": "@id",
      "@container": "@set"
    },
    "owners": {
      "@id": "om:hasOwner",
      "@type": "@id",
      "@container": "@set"
    },
    "reviewers": {
      "@id": "om:hasReviewer",
      "@type": "@id",
      "@container": "@set"
    },
    "tags": {
      "@id": "om:hasTag",
      "@type": "@id",
      "@container": "@set"
    },
    "domains": {
      "@id": "om:belongsToDomain",
      "@type": "@id",
      "@container": "@set"
    },
    "dataProducts": {
      "@id": "om:partOfDataProduct",
      "@type": "@id",
      "@container": "@set"
    },
    "votes": {
      "@id": "om:hasVotes",
      "@type": "@id"
    },
    "childrenCount": {
      "@id": "om:childrenCount",
      "@type": "xsd:integer"
    },
    "disabled": {
      "@id": "om:disabled",
      "@type": "xsd:boolean"
    },
    "mutuallyExclusive": {
      "@id": "om:mutuallyExclusive",
      "@type": "xsd:boolean"
    }
  }
}

{
  "@context": "https://open-metadata.org/context/glossaryTerm.jsonld",
  "@type": ["GlossaryTerm", "Concept"],
  "@id": "https://example.com/glossary/business/Customer",

  "name": "Customer",
  "fullyQualifiedName": "BusinessGlossary.Customer",
  "displayName": "Customer",
  "description": "# Customer\n\nAn individual or organization that purchases goods or services from the company.\n\n## Key Attributes\n- Must have a unique customer ID\n- Can be individual or business entity\n- Has associated contact information",
  "entityStatus": "Approved",

  "synonyms": ["Client", "Account", "Buyer"],

  "glossary": {
    "@id": "https://example.com/glossary/business",
    "@type": "Glossary",
    "name": "BusinessGlossary"
  },

  "parent": {
    "@id": "https://example.com/glossary/business/Party",
    "@type": "GlossaryTerm",
    "name": "Party"
  },

  "children": [
    {
      "@id": "https://example.com/glossary/business/EnterpriseCustomer",
      "@type": "GlossaryTerm",
      "name": "EnterpriseCustomer"
    },
    {
      "@id": "https://example.com/glossary/business/IndividualCustomer",
      "@type": "GlossaryTerm",
      "name": "IndividualCustomer"
    }
  ],

  "relatedTerms": [
    {
      "@id": "https://example.com/glossary/business/Order",
      "@type": "GlossaryTerm",
      "name": "Order"
    },
    {
      "@id": "https://example.com/glossary/business/Revenue",
      "@type": "GlossaryTerm",
      "name": "Revenue"
    }
  ],

  "references": [
    {
      "name": "Customer Definition - Wikipedia",
      "endpoint": "https://en.wikipedia.org/wiki/Customer"
    }
  ],

  "owners": [
    {
      "@id": "https://example.com/users/jane.doe",
      "@type": "User",
      "name": "jane.doe",
      "displayName": "Jane Doe"
    }
  ],

  "reviewers": [
    {
      "@id": "https://example.com/teams/data-governance",
      "@type": "Team",
      "name": "DataGovernance"
    }
  ],

  "tags": [
    {
      "@id": "https://open-metadata.org/tags/Governance/Approved",
      "tagFQN": "Governance.Approved"
    }
  ],

  "domains": [
    {
      "@id": "https://example.com/domains/sales",
      "@type": "Domain",
      "name": "Sales"
    }
  ],

  "dataProducts": [
    {
      "@id": "https://example.com/dataProducts/customer-analytics",
      "@type": "DataProduct",
      "name": "CustomerAnalytics"
    }
  ],

  "usageCount": 45,
  "childrenCount": 2,
  "mutuallyExclusive": false
}