java.lang.Object
- org.odpi.openmetadata.integrationservices.catalog.connector.GlossaryExchangeService

```
public class GlossaryExchangeService
extends Object
```
GlossaryExchangeService is the client for managing resources from a glossary. This includes the glossary container, glossary categories and terms as well as relationships between them.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`attachExternalCategoryLink(String externalLinkGUID, String glossaryCategoryGUID, ExternalGlossaryElementLinkProperties linkProperties, Date effectiveTime)`	Create a link to an external glossary category resource.
`void`	`attachExternalLinkToGlossary(String externalLinkGUID, String glossaryGUID, Date effectiveTime)`	Connect a glossary to a reference to an external glossary resource.
`void`	`attachExternalTermLink(String externalLinkGUID, String glossaryTermGUID, ExternalGlossaryElementLinkProperties linkProperties, Date effectiveTime)`	Create a link to an external glossary term resource.
`void`	`clearCategoryParent(String glossaryParentCategoryGUID, String glossaryChildCategoryGUID, Date effectiveTime)`	Remove a parent-child relationship between two categories.
`void`	`clearGlossaryAsCanonical(String glossaryGUID, String glossaryExternalIdentifier)`	Remove the canonical designation from the glossary.
`void`	`clearGlossaryAsTaxonomy(String glossaryGUID, String glossaryExternalIdentifier)`	Remove the taxonomy designation from the glossary.
`void`	`clearTermAsAbstractConcept(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime)`	Remove the abstract concept designation from the glossary term.
`void`	`clearTermAsActivity(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime)`	Remove the activity designation from the glossary term.
`void`	`clearTermAsContext(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime)`	Remove the context definition designation from the glossary term.
`void`	`clearTermAsDataValue(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime)`	Remove the data value designation from the glossary term.
`void`	`clearTermAsObjectIdentifier(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime)`	Remove the object identifier designation from the glossary term.
`void`	`clearTermAsSpineAttribute(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime)`	Remove the spine attribute designation from the glossary term.
`void`	`clearTermAsSpineObject(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime)`	Remove the spine object designation from the glossary term.
`void`	`clearTermCategory(String glossaryCategoryGUID, String glossaryTermGUID, Date effectiveTime)`	Unlink a term from a category.
`void`	`clearTermRelationship(String relationshipTypeName, String glossaryTermOneGUID, String glossaryTermTwoGUID, Date effectiveTime)`	Remove the relationship between two terms.
`String`	`createControlledGlossaryTerm(String userId, String assetManagerGUID, String assetManagerName, String glossaryGUID, ExternalIdentifierProperties externalIdentifierProperties, GlossaryTermProperties glossaryTermProperties, GlossaryTermStatus initialStatus)`	Create a new metadata element to represent a glossary term whose lifecycle is managed through a controlled workflow.
`String`	`createExternalGlossaryLink(ExternalGlossaryLinkProperties linkProperties)`	Create a link to an external glossary resource.
`String`	`createGlossary(ExternalIdentifierProperties externalIdentifierProperties, GlossaryProperties glossaryProperties)`	Create a new metadata element to represent the root of a glossary.
`String`	`createGlossaryCategory(String glossaryGUID, ExternalIdentifierProperties externalIdentifierProperties, GlossaryCategoryProperties glossaryCategoryProperties)`	Create a new metadata element to represent a glossary category.
`String`	`createGlossaryCategoryFromTemplate(String templateGUID, ExternalIdentifierProperties externalIdentifierProperties, TemplateProperties templateProperties)`	Create a new metadata element to represent a glossary category using an existing metadata element as a template.
`String`	`createGlossaryFromTemplate(String templateGUID, ExternalIdentifierProperties externalIdentifierProperties, TemplateProperties templateProperties)`	Create a new metadata element to represent a glossary using an existing metadata element as a template.
`String`	`createGlossaryTerm(String glossaryGUID, ExternalIdentifierProperties externalIdentifierProperties, GlossaryTermProperties glossaryTermProperties)`	Create a new metadata element to represent a glossary term.
`String`	`createGlossaryTermFromTemplate(String templateGUID, ExternalIdentifierProperties externalIdentifierProperties, TemplateProperties templateProperties)`	Create a new metadata element to represent a glossary term using an existing metadata element as a template.
`void`	`detachExternalCategoryLink(String externalLinkGUID, String glossaryCategoryGUID, Date effectiveTime)`	Remove the link to an external glossary category resource.
`void`	`detachExternalLinkFromGlossary(String externalLinkGUID, String glossaryGUID, Date effectiveTime)`	Disconnect a glossary from a reference to an external glossary resource.
`void`	`detachExternalTermLink(String externalLinkGUID, String glossaryTermGUID, Date effectiveTime)`	Remove the link to an external glossary term resource.
`List<GlossaryElement>`	`findGlossaries(String searchString, int startFrom, int pageSize)`	Retrieve the list of glossary metadata elements that contain the search string.
`List<GlossaryCategoryElement>`	`findGlossaryCategories(String searchString, int startFrom, int pageSize, Date effectiveTime)`	Retrieve the list of glossary category metadata elements that contain the search string.
`List<GlossaryTermElement>`	`findGlossaryTerms(String searchString, int startFrom, int pageSize, Date effectiveTime)`	Retrieve the list of glossary term metadata elements that contain the search string.
`List<GlossaryCategoryElement>`	`getCategoriesForGlossary(String glossaryGUID, int startFrom, int pageSize, Date effectiveTime)`	Return the list of categories associated with a glossary.
`List<ExternalGlossaryLinkElement>`	`getExternalLinksForGlossary(String glossaryGUID, int startFrom, int pageSize, Date effectiveTime)`	Retrieve the list of links to external glossary resources attached to a glossary.
`List<GlossaryElement>`	`getGlossariesByName(String name, int startFrom, int pageSize)`	Retrieve the list of glossary metadata elements with a matching qualified or display name.
`List<GlossaryElement>`	`getGlossariesForAssetManager(int startFrom, int pageSize)`	Retrieve the list of glossaries created on behalf of this asset manager.
`List<GlossaryElement>`	`getGlossariesForExternalLink(String externalLinkGUID, int startFrom, int pageSize, Date effectiveTime)`	Return the glossaries connected to an external glossary source.
`GlossaryElement`	`getGlossaryByGUID(String openMetadataGUID)`	Retrieve the glossary metadata element with the supplied unique identifier.
`List<GlossaryCategoryElement>`	`getGlossaryCategoriesByName(String name, int startFrom, int pageSize, Date effectiveTime)`	Retrieve the list of glossary category metadata elements with a matching qualified or display name.
`GlossaryCategoryElement`	`getGlossaryCategoryByGUID(String guid, Date effectiveTime)`	Retrieve the glossary category metadata element with the supplied unique identifier.
`GlossaryCategoryElement`	`getGlossaryCategoryParent(String userId, String assetManagerGUID, String assetManagerName, String glossaryCategoryGUID, Date effectiveTime)`	Retrieve the glossary category metadata element with the supplied unique identifier.
`List<GlossaryCategoryElement>`	`getGlossarySubCategories(String userId, String assetManagerGUID, String assetManagerName, String glossaryCategoryGUID, int startFrom, int pageSize, Date effectiveTime)`	Retrieve the glossary category metadata element with the supplied unique identifier.
`GlossaryTermElement`	`getGlossaryTermByGUID(String guid, Date effectiveTime)`	Retrieve the glossary term metadata element with the supplied unique identifier.
`List<GlossaryTermElement>`	`getGlossaryTermsByName(String name, int startFrom, int pageSize, Date effectiveTime)`	Retrieve the list of glossary term metadata elements with a matching qualified or display name.
`List<GlossaryTermElement>`	`getTermsForGlossary(String glossaryGUID, int startFrom, int pageSize, Date effectiveTime)`	Retrieve the list of glossary terms associated with a glossary.
`List<GlossaryTermElement>`	`getTermsForGlossaryCategory(String glossaryCategoryGUID, int startFrom, int pageSize, Date effectiveTime)`	Retrieve the list of glossary terms associated with a glossary category.
`boolean`	`isForDuplicateProcessing()`	Return whether retrieval requests from this service are to avoid merging duplicates or not.
`boolean`	`isForLineage()`	Return whether retrieval requests from this service are to include elements with the Memento classification attached or not.
`void`	`removeExternalGlossaryLink(String externalLinkGUID, Date effectiveTime)`	Remove information about a link to an external glossary resource (and the relationships that attached it to the glossaries).
`void`	`removeGlossary(String glossaryGUID, String glossaryExternalIdentifier)`	Remove the metadata element representing a glossary.
`void`	`removeGlossaryCategory(String glossaryCategoryGUID, String glossaryCategoryExternalIdentifier, Date effectiveTime)`	Remove the metadata element representing a glossary category.
`void`	`removeGlossaryTerm(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime)`	Remove the metadata element representing a glossary term.
`void`	`setForDuplicateProcessing(boolean forDuplicateProcessing)`	Set up whether retrieval requests from this service are to avoid merging duplicates or not.
`void`	`setForLineage(boolean forLineage)`	Set up whether retrieval requests from this service are to include elements with the Memento classification attached or not.
`void`	`setGlossaryAsCanonical(String glossaryGUID, String glossaryExternalIdentifier, String scope)`	Classify a glossary to declare that it has no two GlossaryTerm definitions with the same name.
`void`	`setGlossaryAsTaxonomy(String glossaryGUID, String glossaryExternalIdentifier, String organizingPrinciple)`	Classify the glossary to indicate that it can be used as a taxonomy.
`void`	`setTermAsAbstractConcept(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime)`	Classify the glossary term to indicate that it describes an abstract concept.
`void`	`setTermAsActivity(String glossaryTermGUID, String glossaryTermExternalIdentifier, GlossaryTermActivityType activityType, Date effectiveTime)`	Classify the glossary term to indicate that it describes a data value.
`void`	`setTermAsContext(String glossaryTermGUID, String glossaryTermExternalIdentifier, GlossaryTermContextDefinition contextDefinition, Date effectiveTime)`	Classify the glossary term to indicate that it describes a context.
`void`	`setTermAsDataValue(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime)`	Classify the glossary term to indicate that it describes a data value.
`void`	`setTermAsObjectIdentifier(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime)`	Classify the glossary term to indicate that it describes an object identifier.
`void`	`setTermAsSpineAttribute(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime)`	Classify the glossary term to indicate that it describes a spine attribute.
`void`	`setTermAsSpineObject(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime)`	Classify the glossary term to indicate that it describes a spine object.
`void`	`setupCategoryParent(String glossaryParentCategoryGUID, String glossaryChildCategoryGUID, Date effectiveTime)`	Create a parent-child relationship between two categories.
`void`	`setupTermCategory(String glossaryCategoryGUID, String glossaryTermGUID, GlossaryTermCategorization categorizationProperties, Date effectiveTime)`	Link a term to a category.
`void`	`setupTermRelationship(String relationshipTypeName, String glossaryTermOneGUID, String glossaryTermTwoGUID, GlossaryTermRelationship relationshipsProperties, Date effectiveTime)`	Link two terms together using a specialist relationship.
`void`	`updateExternalGlossaryLink(String externalLinkGUID, boolean isMergeUpdate, ExternalGlossaryLinkProperties linkProperties, Date effectiveTime)`	Update the properties of a reference to an external glossary resource.
`void`	`updateGlossary(String glossaryGUID, String glossaryExternalIdentifier, GlossaryProperties glossaryProperties)`	Update the metadata element representing a glossary.
`void`	`updateGlossaryCategory(String glossaryCategoryGUID, String glossaryCategoryExternalIdentifier, boolean isMergeUpdate, GlossaryCategoryProperties glossaryCategoryProperties, Date effectiveTime)`	Update the metadata element representing a glossary category.
`void`	`updateGlossaryTerm(String glossaryTermGUID, String glossaryTermExternalIdentifier, boolean isMergeUpdate, GlossaryTermProperties glossaryTermProperties, Date effectiveTime)`	Update the properties of the metadata element representing a glossary term.
`void`	`updateGlossaryTermStatus(String userId, String assetManagerGUID, String assetManagerName, String glossaryTermGUID, String glossaryTermExternalIdentifier, GlossaryTermStatus glossaryTermStatus, Date effectiveTime)`	Update the status of the metadata element representing a glossary term.
`void`	`updateTermRelationship(String relationshipTypeName, String glossaryTermOneGUID, String glossaryTermTwoGUID, GlossaryTermRelationship relationshipsProperties, Date effectiveTime)`	Update the relationship properties for the two terms.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - isForLineage
```
public boolean isForLineage()
```
    Return whether retrieval requests from this service are to include elements with the Memento classification attached or not.
    
    Returns:
    
    boolean flag
  - setForLineage
```
public void setForLineage(boolean forLineage)
```
    Set up whether retrieval requests from this service are to include elements with the Memento classification attached or not.
    
    Parameters:
    
    forLineage - boolean flag
  - isForDuplicateProcessing
```
public boolean isForDuplicateProcessing()
```
    Return whether retrieval requests from this service are to avoid merging duplicates or not.
    
    Returns:
    
    boolean flag
  - setForDuplicateProcessing
```
public void setForDuplicateProcessing(boolean forDuplicateProcessing)
```
    Set up whether retrieval requests from this service are to avoid merging duplicates or not.
    
    Parameters:
    
    forDuplicateProcessing - boolean flag
  - createGlossary
```
public String createGlossary(ExternalIdentifierProperties externalIdentifierProperties,
                             GlossaryProperties glossaryProperties)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException
```
    Create a new metadata element to represent the root of a glossary. All categories and terms are linked to a single glossary. They are owned by this glossary and if the glossary is deleted, any linked terms and categories are deleted as well.
    
    Parameters:
    
    externalIdentifierProperties - optional properties used to define an external identifier
    
    glossaryProperties - properties to store
    
    Returns:
    
    unique identifier of the new metadata element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - createGlossaryFromTemplate
```
public String createGlossaryFromTemplate(String templateGUID,
                                         ExternalIdentifierProperties externalIdentifierProperties,
                                         TemplateProperties templateProperties)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
```
    Create a new metadata element to represent a glossary using an existing metadata element as a template. The template defines additional classifications and relationships that should be added to the new glossary. All categories and terms are linked to a single glossary. They are owned by this glossary and if the glossary is deleted, any linked terms and categories are deleted as well.
    
    Parameters:
    
    templateGUID - unique identifier of the metadata element to copy
    
    externalIdentifierProperties - optional properties used to define an external identifier
    
    templateProperties - properties that override the template
    
    Returns:
    
    unique identifier of the new metadata element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updateGlossary
```
public void updateGlossary(String glossaryGUID,
                           String glossaryExternalIdentifier,
                           GlossaryProperties glossaryProperties)
                    throws InvalidParameterException,
                           UserNotAuthorizedException,
                           PropertyServerException
```
    Update the metadata element representing a glossary.
    
    Parameters:
    
    glossaryGUID - unique identifier of the metadata element to update
    
    glossaryExternalIdentifier - unique identifier of the glossary in the external asset manager
    
    glossaryProperties - new properties for this element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - removeGlossary
```
public void removeGlossary(String glossaryGUID,
                           String glossaryExternalIdentifier)
                    throws InvalidParameterException,
                           UserNotAuthorizedException,
                           PropertyServerException
```
    Remove the metadata element representing a glossary. This will delete the glossary and all categories and terms - use with care :)
    
    Parameters:
    
    glossaryGUID - unique identifier of the metadata element to remove
    
    glossaryExternalIdentifier - unique identifier of the glossary in the external asset manager
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setGlossaryAsTaxonomy
```
public void setGlossaryAsTaxonomy(String glossaryGUID,
                                  String glossaryExternalIdentifier,
                                  String organizingPrinciple)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException
```
    Classify the glossary to indicate that it can be used as a taxonomy. This means each term is attached to one, and only one category and the categories are organized as a hierarchy with a single root category. Taxonomies are used as a way of organizing assets and other related metadata. The terms in the taxonomy are linked to the assets etc. and as such they are logically categorized by the linked category.
    
    Parameters:
    
    glossaryGUID - unique identifier of the metadata element to remove
    
    glossaryExternalIdentifier - unique identifier of the glossary in the external asset manager
    
    organizingPrinciple - description of how the glossary is organized
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearGlossaryAsTaxonomy
```
public void clearGlossaryAsTaxonomy(String glossaryGUID,
                                    String glossaryExternalIdentifier)
                             throws InvalidParameterException,
                                    UserNotAuthorizedException,
                                    PropertyServerException
```
    Remove the taxonomy designation from the glossary.
    
    Parameters:
    
    glossaryGUID - unique identifier of the metadata element to remove
    
    glossaryExternalIdentifier - unique identifier of the glossary in the external asset manager
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setGlossaryAsCanonical
```
public void setGlossaryAsCanonical(String glossaryGUID,
                                   String glossaryExternalIdentifier,
                                   String scope)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException
```
    Classify a glossary to declare that it has no two GlossaryTerm definitions with the same name. This means there is only one definition for each term. Typically, the terms are also of a similar level of granularity and are limited to a specific scope of use. Canonical vocabularies are used to semantically classify assets in an unambiguous way.
    
    Parameters:
    
    glossaryGUID - unique identifier of the metadata element to remove
    
    glossaryExternalIdentifier - unique identifier of the glossary in the external asset manager
    
    scope - description of the situations where this glossary is relevant.
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearGlossaryAsCanonical
```
public void clearGlossaryAsCanonical(String glossaryGUID,
                                     String glossaryExternalIdentifier)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     PropertyServerException
```
    Remove the canonical designation from the glossary.
    
    Parameters:
    
    glossaryGUID - unique identifier of the metadata element to remove
    
    glossaryExternalIdentifier - unique identifier of the glossary in the external asset manager
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - findGlossaries
```
public List<GlossaryElement> findGlossaries(String searchString,
                                            int startFrom,
                                            int pageSize)
                                     throws InvalidParameterException,
                                            UserNotAuthorizedException,
                                            PropertyServerException
```
    Retrieve the list of glossary metadata elements that contain the search string. The search string is treated as a regular expression.
    
    Parameters:
    
    searchString - string to find in the properties
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getGlossariesByName
```
public List<GlossaryElement> getGlossariesByName(String name,
                                                 int startFrom,
                                                 int pageSize)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 PropertyServerException
```
    Retrieve the list of glossary metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
    
    Parameters:
    
    name - name to search for
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getGlossariesForAssetManager
```
public List<GlossaryElement> getGlossariesForAssetManager(int startFrom,
                                                          int pageSize)
                                                   throws InvalidParameterException,
                                                          UserNotAuthorizedException,
                                                          PropertyServerException
```
    Retrieve the list of glossaries created on behalf of this asset manager.
    
    Parameters:
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getGlossaryByGUID
```
public GlossaryElement getGlossaryByGUID(String openMetadataGUID)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
```
    Retrieve the glossary metadata element with the supplied unique identifier.
    
    Parameters:
    
    openMetadataGUID - unique identifier of the requested metadata element
    
    Returns:
    
    matching metadata element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - createGlossaryCategory
```
public String createGlossaryCategory(String glossaryGUID,
                                     ExternalIdentifierProperties externalIdentifierProperties,
                                     GlossaryCategoryProperties glossaryCategoryProperties)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     PropertyServerException
```
    Create a new metadata element to represent a glossary category.
    
    Parameters:
    
    glossaryGUID - unique identifier of anchor glossary
    
    externalIdentifierProperties - optional properties used to define an external identifier
    
    glossaryCategoryProperties - properties about the glossary category to store
    
    Returns:
    
    unique identifier of the new glossary category
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - createGlossaryCategoryFromTemplate
```
public String createGlossaryCategoryFromTemplate(String templateGUID,
                                                 ExternalIdentifierProperties externalIdentifierProperties,
                                                 TemplateProperties templateProperties)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 PropertyServerException
```
    Create a new metadata element to represent a glossary category using an existing metadata element as a template.
    
    Parameters:
    
    templateGUID - unique identifier of the metadata element to copy
    
    externalIdentifierProperties - optional properties used to define an external identifier
    
    templateProperties - properties that override the template
    
    Returns:
    
    unique identifier of the new glossary category
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updateGlossaryCategory
```
public void updateGlossaryCategory(String glossaryCategoryGUID,
                                   String glossaryCategoryExternalIdentifier,
                                   boolean isMergeUpdate,
                                   GlossaryCategoryProperties glossaryCategoryProperties,
                                   Date effectiveTime)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException
```
    Update the metadata element representing a glossary category.
    
    Parameters:
    
    glossaryCategoryGUID - unique identifier of the metadata element to update
    
    glossaryCategoryExternalIdentifier - unique identifier of the glossary category in the external asset manager
    
    isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
    
    glossaryCategoryProperties - new properties for the metadata element
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setupCategoryParent
```
public void setupCategoryParent(String glossaryParentCategoryGUID,
                                String glossaryChildCategoryGUID,
                                Date effectiveTime)
                         throws InvalidParameterException,
                                UserNotAuthorizedException,
                                PropertyServerException
```
    Create a parent-child relationship between two categories.
    
    Parameters:
    
    glossaryParentCategoryGUID - unique identifier of the glossary category in the external asset manager that is to be the super-category
    
    glossaryChildCategoryGUID - unique identifier of the glossary category in the external asset manager that is to be the subcategory
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearCategoryParent
```
public void clearCategoryParent(String glossaryParentCategoryGUID,
                                String glossaryChildCategoryGUID,
                                Date effectiveTime)
                         throws InvalidParameterException,
                                UserNotAuthorizedException,
                                PropertyServerException
```
    Remove a parent-child relationship between two categories.
    
    Parameters:
    
    glossaryParentCategoryGUID - unique identifier of the glossary category in the external asset manager that is to be the super-category
    
    glossaryChildCategoryGUID - unique identifier of the glossary category in the external asset manager that is to be the subcategory
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - removeGlossaryCategory
```
public void removeGlossaryCategory(String glossaryCategoryGUID,
                                   String glossaryCategoryExternalIdentifier,
                                   Date effectiveTime)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException
```
    Remove the metadata element representing a glossary category.
    
    Parameters:
    
    glossaryCategoryGUID - unique identifier of the metadata element to remove
    
    glossaryCategoryExternalIdentifier - unique identifier of the glossary category in the external asset manager
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - findGlossaryCategories
```
public List<GlossaryCategoryElement> findGlossaryCategories(String searchString,
                                                            int startFrom,
                                                            int pageSize,
                                                            Date effectiveTime)
                                                     throws InvalidParameterException,
                                                            UserNotAuthorizedException,
                                                            PropertyServerException
```
    Retrieve the list of glossary category metadata elements that contain the search string. The search string is treated as a regular expression.
    
    Parameters:
    
    searchString - string to find in the properties
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getCategoriesForGlossary
```
public List<GlossaryCategoryElement> getCategoriesForGlossary(String glossaryGUID,
                                                              int startFrom,
                                                              int pageSize,
                                                              Date effectiveTime)
                                                       throws InvalidParameterException,
                                                              UserNotAuthorizedException,
                                                              PropertyServerException
```
    Return the list of categories associated with a glossary.
    
    Parameters:
    
    glossaryGUID - unique identifier of the glossary to query
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Returns:
    
    list of metadata elements describing the categories associated with the requested glossary
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getGlossaryCategoriesByName
```
public List<GlossaryCategoryElement> getGlossaryCategoriesByName(String name,
                                                                 int startFrom,
                                                                 int pageSize,
                                                                 Date effectiveTime)
                                                          throws InvalidParameterException,
                                                                 UserNotAuthorizedException,
                                                                 PropertyServerException
```
    Retrieve the list of glossary category metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
    
    Parameters:
    
    name - name to search for
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getGlossaryCategoryByGUID
```
public GlossaryCategoryElement getGlossaryCategoryByGUID(String guid,
                                                         Date effectiveTime)
                                                  throws InvalidParameterException,
                                                         UserNotAuthorizedException,
                                                         PropertyServerException
```
    Retrieve the glossary category metadata element with the supplied unique identifier.
    
    Parameters:
    
    guid - unique identifier of the requested metadata element
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Returns:
    
    requested metadata element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getGlossaryCategoryParent
```
public GlossaryCategoryElement getGlossaryCategoryParent(String userId,
                                                         String assetManagerGUID,
                                                         String assetManagerName,
                                                         String glossaryCategoryGUID,
                                                         Date effectiveTime)
                                                  throws InvalidParameterException,
                                                         UserNotAuthorizedException,
                                                         PropertyServerException
```
    Retrieve the glossary category metadata element with the supplied unique identifier.
    
    Parameters:
    
    userId - calling user
    
    assetManagerGUID - unique identifier of software server capability representing the caller
    
    assetManagerName - unique name of software server capability representing the caller
    
    glossaryCategoryGUID - unique identifier of the requested metadata element
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Returns:
    
    parent glossary category element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getGlossarySubCategories
```
public List<GlossaryCategoryElement> getGlossarySubCategories(String userId,
                                                              String assetManagerGUID,
                                                              String assetManagerName,
                                                              String glossaryCategoryGUID,
                                                              int startFrom,
                                                              int pageSize,
                                                              Date effectiveTime)
                                                       throws InvalidParameterException,
                                                              UserNotAuthorizedException,
                                                              PropertyServerException
```
    Retrieve the glossary category metadata element with the supplied unique identifier.
    
    Parameters:
    
    userId - calling user
    
    assetManagerGUID - unique identifier of software server capability representing the caller
    
    assetManagerName - unique name of software server capability representing the caller
    
    glossaryCategoryGUID - unique identifier of the requested metadata element
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Returns:
    
    list of glossary category element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - createGlossaryTerm
```
public String createGlossaryTerm(String glossaryGUID,
                                 ExternalIdentifierProperties externalIdentifierProperties,
                                 GlossaryTermProperties glossaryTermProperties)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 PropertyServerException
```
    Create a new metadata element to represent a glossary term.
    
    Parameters:
    
    glossaryGUID - unique identifier of the glossary where the term is located
    
    externalIdentifierProperties - optional properties used to define an external identifier
    
    glossaryTermProperties - properties for the glossary term
    
    Returns:
    
    unique identifier of the new metadata element for the glossary term
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - createControlledGlossaryTerm
```
public String createControlledGlossaryTerm(String userId,
                                           String assetManagerGUID,
                                           String assetManagerName,
                                           String glossaryGUID,
                                           ExternalIdentifierProperties externalIdentifierProperties,
                                           GlossaryTermProperties glossaryTermProperties,
                                           GlossaryTermStatus initialStatus)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           PropertyServerException
```
    Create a new metadata element to represent a glossary term whose lifecycle is managed through a controlled workflow.
    
    Parameters:
    
    userId - calling user
    
    assetManagerGUID - unique identifier of software server capability representing the caller
    
    assetManagerName - unique name of software server capability representing the caller
    
    glossaryGUID - unique identifier of the glossary where the term is located
    
    externalIdentifierProperties - optional properties used to define an external identifier
    
    glossaryTermProperties - properties for the glossary term
    
    initialStatus - glossary term status to use when the object is created
    
    Returns:
    
    unique identifier of the new metadata element for the glossary term
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - createGlossaryTermFromTemplate
```
public String createGlossaryTermFromTemplate(String templateGUID,
                                             ExternalIdentifierProperties externalIdentifierProperties,
                                             TemplateProperties templateProperties)
                                      throws InvalidParameterException,
                                             UserNotAuthorizedException,
                                             PropertyServerException
```
    Create a new metadata element to represent a glossary term using an existing metadata element as a template.
    
    Parameters:
    
    templateGUID - unique identifier of the metadata element to copy
    
    externalIdentifierProperties - optional properties used to define an external identifier
    
    templateProperties - properties that override the template
    
    Returns:
    
    unique identifier of the new metadata element for the glossary term
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updateGlossaryTerm
```
public void updateGlossaryTerm(String glossaryTermGUID,
                               String glossaryTermExternalIdentifier,
                               boolean isMergeUpdate,
                               GlossaryTermProperties glossaryTermProperties,
                               Date effectiveTime)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               PropertyServerException
```
    Update the properties of the metadata element representing a glossary term.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the glossary term to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
    
    glossaryTermProperties - new properties for the glossary term
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updateGlossaryTermStatus
```
public void updateGlossaryTermStatus(String userId,
                                     String assetManagerGUID,
                                     String assetManagerName,
                                     String glossaryTermGUID,
                                     String glossaryTermExternalIdentifier,
                                     GlossaryTermStatus glossaryTermStatus,
                                     Date effectiveTime)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     PropertyServerException
```
    Update the status of the metadata element representing a glossary term. This is only valid on a controlled glossary term.
    
    Parameters:
    
    userId - calling user
    
    assetManagerGUID - unique identifier of software server capability representing the caller
    
    assetManagerName - unique name of software server capability representing the caller
    
    glossaryTermGUID - unique identifier of the glossary term to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    glossaryTermStatus - new properties for the glossary term
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setupTermCategory
```
public void setupTermCategory(String glossaryCategoryGUID,
                              String glossaryTermGUID,
                              GlossaryTermCategorization categorizationProperties,
                              Date effectiveTime)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              PropertyServerException
```
    Link a term to a category.
    
    Parameters:
    
    glossaryCategoryGUID - unique identifier of the glossary category
    
    glossaryTermGUID - unique identifier of the glossary term
    
    categorizationProperties - properties for the categorization relationship
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearTermCategory
```
public void clearTermCategory(String glossaryCategoryGUID,
                              String glossaryTermGUID,
                              Date effectiveTime)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              PropertyServerException
```
    Unlink a term from a category.
    
    Parameters:
    
    glossaryCategoryGUID - unique identifier of the glossary category
    
    glossaryTermGUID - unique identifier of the glossary term
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setupTermRelationship
```
public void setupTermRelationship(String relationshipTypeName,
                                  String glossaryTermOneGUID,
                                  String glossaryTermTwoGUID,
                                  GlossaryTermRelationship relationshipsProperties,
                                  Date effectiveTime)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException
```
    Link two terms together using a specialist relationship.
    
    Parameters:
    
    relationshipTypeName - name of the type of relationship to create
    
    glossaryTermOneGUID - unique identifier of the glossary term at end 1
    
    glossaryTermTwoGUID - unique identifier of the glossary term at end 2
    
    relationshipsProperties - properties for the categorization relationship
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updateTermRelationship
```
public void updateTermRelationship(String relationshipTypeName,
                                   String glossaryTermOneGUID,
                                   String glossaryTermTwoGUID,
                                   GlossaryTermRelationship relationshipsProperties,
                                   Date effectiveTime)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException
```
    Update the relationship properties for the two terms.
    
    Parameters:
    
    relationshipTypeName - name of the type of relationship to create
    
    glossaryTermOneGUID - unique identifier of the glossary term at end 1
    
    glossaryTermTwoGUID - unique identifier of the glossary term at end 2
    
    relationshipsProperties - properties for the categorization relationship
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearTermRelationship
```
public void clearTermRelationship(String relationshipTypeName,
                                  String glossaryTermOneGUID,
                                  String glossaryTermTwoGUID,
                                  Date effectiveTime)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException
```
    Remove the relationship between two terms.
    
    Parameters:
    
    relationshipTypeName - name of the type of relationship to create
    
    glossaryTermOneGUID - unique identifier of the glossary term at end 1
    
    glossaryTermTwoGUID - unique identifier of the glossary term at end 2
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setTermAsAbstractConcept
```
public void setTermAsAbstractConcept(String glossaryTermGUID,
                                     String glossaryTermExternalIdentifier,
                                     Date effectiveTime)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     PropertyServerException
```
    Classify the glossary term to indicate that it describes an abstract concept.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the metadata element to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearTermAsAbstractConcept
```
public void clearTermAsAbstractConcept(String glossaryTermGUID,
                                       String glossaryTermExternalIdentifier,
                                       Date effectiveTime)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException
```
    Remove the abstract concept designation from the glossary term.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the metadata element to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setTermAsDataValue
```
public void setTermAsDataValue(String glossaryTermGUID,
                               String glossaryTermExternalIdentifier,
                               Date effectiveTime)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               PropertyServerException
```
    Classify the glossary term to indicate that it describes a data value.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the metadata element to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearTermAsDataValue
```
public void clearTermAsDataValue(String glossaryTermGUID,
                                 String glossaryTermExternalIdentifier,
                                 Date effectiveTime)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 PropertyServerException
```
    Remove the data value designation from the glossary term.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the metadata element to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setTermAsActivity
```
public void setTermAsActivity(String glossaryTermGUID,
                              String glossaryTermExternalIdentifier,
                              GlossaryTermActivityType activityType,
                              Date effectiveTime)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              PropertyServerException
```
    Classify the glossary term to indicate that it describes a data value.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the metadata element to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    activityType - type of activity
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearTermAsActivity
```
public void clearTermAsActivity(String glossaryTermGUID,
                                String glossaryTermExternalIdentifier,
                                Date effectiveTime)
                         throws InvalidParameterException,
                                UserNotAuthorizedException,
                                PropertyServerException
```
    Remove the activity designation from the glossary term.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the metadata element to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setTermAsContext
```
public void setTermAsContext(String glossaryTermGUID,
                             String glossaryTermExternalIdentifier,
                             GlossaryTermContextDefinition contextDefinition,
                             Date effectiveTime)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException
```
    Classify the glossary term to indicate that it describes a context.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the metadata element to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    contextDefinition - more details of the context
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearTermAsContext
```
public void clearTermAsContext(String glossaryTermGUID,
                               String glossaryTermExternalIdentifier,
                               Date effectiveTime)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               PropertyServerException
```
    Remove the context definition designation from the glossary term.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the metadata element to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setTermAsSpineObject
```
public void setTermAsSpineObject(String glossaryTermGUID,
                                 String glossaryTermExternalIdentifier,
                                 Date effectiveTime)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 PropertyServerException
```
    Classify the glossary term to indicate that it describes a spine object.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the metadata element to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearTermAsSpineObject
```
public void clearTermAsSpineObject(String glossaryTermGUID,
                                   String glossaryTermExternalIdentifier,
                                   Date effectiveTime)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException
```
    Remove the spine object designation from the glossary term.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the metadata element to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setTermAsSpineAttribute
```
public void setTermAsSpineAttribute(String glossaryTermGUID,
                                    String glossaryTermExternalIdentifier,
                                    Date effectiveTime)
                             throws InvalidParameterException,
                                    UserNotAuthorizedException,
                                    PropertyServerException
```
    Classify the glossary term to indicate that it describes a spine attribute.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the metadata element to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearTermAsSpineAttribute
```
public void clearTermAsSpineAttribute(String glossaryTermGUID,
                                      String glossaryTermExternalIdentifier,
                                      Date effectiveTime)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      PropertyServerException
```
    Remove the spine attribute designation from the glossary term.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the metadata element to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setTermAsObjectIdentifier
```
public void setTermAsObjectIdentifier(String glossaryTermGUID,
                                      String glossaryTermExternalIdentifier,
                                      Date effectiveTime)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      PropertyServerException
```
    Classify the glossary term to indicate that it describes an object identifier.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the metadata element to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearTermAsObjectIdentifier
```
public void clearTermAsObjectIdentifier(String glossaryTermGUID,
                                        String glossaryTermExternalIdentifier,
                                        Date effectiveTime)
                                 throws InvalidParameterException,
                                        UserNotAuthorizedException,
                                        PropertyServerException
```
    Remove the object identifier designation from the glossary term.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the metadata element to update
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - removeGlossaryTerm
```
public void removeGlossaryTerm(String glossaryTermGUID,
                               String glossaryTermExternalIdentifier,
                               Date effectiveTime)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               PropertyServerException
```
    Remove the metadata element representing a glossary term.
    
    Parameters:
    
    glossaryTermGUID - unique identifier of the metadata element to remove
    
    glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - findGlossaryTerms
```
public List<GlossaryTermElement> findGlossaryTerms(String searchString,
                                                   int startFrom,
                                                   int pageSize,
                                                   Date effectiveTime)
                                            throws InvalidParameterException,
                                                   UserNotAuthorizedException,
                                                   PropertyServerException
```
    Retrieve the list of glossary term metadata elements that contain the search string. The search string is treated as a regular expression.
    
    Parameters:
    
    searchString - string to find in the properties
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getTermsForGlossary
```
public List<GlossaryTermElement> getTermsForGlossary(String glossaryGUID,
                                                     int startFrom,
                                                     int pageSize,
                                                     Date effectiveTime)
                                              throws InvalidParameterException,
                                                     UserNotAuthorizedException,
                                                     PropertyServerException
```
    Retrieve the list of glossary terms associated with a glossary.
    
    Parameters:
    
    glossaryGUID - unique identifier of the glossary of interest
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Returns:
    
    list of associated metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getTermsForGlossaryCategory
```
public List<GlossaryTermElement> getTermsForGlossaryCategory(String glossaryCategoryGUID,
                                                             int startFrom,
                                                             int pageSize,
                                                             Date effectiveTime)
                                                      throws InvalidParameterException,
                                                             UserNotAuthorizedException,
                                                             PropertyServerException
```
    Retrieve the list of glossary terms associated with a glossary category.
    
    Parameters:
    
    glossaryCategoryGUID - unique identifier of the glossary category of interest
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Returns:
    
    list of associated metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getGlossaryTermsByName
```
public List<GlossaryTermElement> getGlossaryTermsByName(String name,
                                                        int startFrom,
                                                        int pageSize,
                                                        Date effectiveTime)
                                                 throws InvalidParameterException,
                                                        UserNotAuthorizedException,
                                                        PropertyServerException
```
    Retrieve the list of glossary term metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
    
    Parameters:
    
    name - name to search for
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getGlossaryTermByGUID
```
public GlossaryTermElement getGlossaryTermByGUID(String guid,
                                                 Date effectiveTime)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 PropertyServerException
```
    Retrieve the glossary term metadata element with the supplied unique identifier.
    
    Parameters:
    
    guid - unique identifier of the requested metadata element
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Returns:
    
    matching metadata element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - createExternalGlossaryLink
```
public String createExternalGlossaryLink(ExternalGlossaryLinkProperties linkProperties)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
```
    Create a link to an external glossary resource. This is associated with a glossary to show that they have equivalent content. It is possible that this resource was generated from the glossary content or was the source for it.
    
    Parameters:
    
    linkProperties - properties of the link
    
    Returns:
    
    unique identifier of the external reference
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updateExternalGlossaryLink
```
public void updateExternalGlossaryLink(String externalLinkGUID,
                                       boolean isMergeUpdate,
                                       ExternalGlossaryLinkProperties linkProperties,
                                       Date effectiveTime)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException
```
    Update the properties of a reference to an external glossary resource.
    
    Parameters:
    
    externalLinkGUID - unique identifier of the external reference
    
    linkProperties - properties of the link
    
    isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - removeExternalGlossaryLink
```
public void removeExternalGlossaryLink(String externalLinkGUID,
                                       Date effectiveTime)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException
```
    Remove information about a link to an external glossary resource (and the relationships that attached it to the glossaries).
    
    Parameters:
    
    externalLinkGUID - unique identifier of the external reference
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - attachExternalLinkToGlossary
```
public void attachExternalLinkToGlossary(String externalLinkGUID,
                                         String glossaryGUID,
                                         Date effectiveTime)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
```
    Connect a glossary to a reference to an external glossary resource.
    
    Parameters:
    
    externalLinkGUID - unique identifier of the external reference
    
    glossaryGUID - unique identifier of the metadata element to attach
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - detachExternalLinkFromGlossary
```
public void detachExternalLinkFromGlossary(String externalLinkGUID,
                                           String glossaryGUID,
                                           Date effectiveTime)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           PropertyServerException
```
    Disconnect a glossary from a reference to an external glossary resource.
    
    Parameters:
    
    externalLinkGUID - unique identifier of the external reference
    
    glossaryGUID - unique identifier of the metadata element to remove
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getExternalLinksForGlossary
```
public List<ExternalGlossaryLinkElement> getExternalLinksForGlossary(String glossaryGUID,
                                                                     int startFrom,
                                                                     int pageSize,
                                                                     Date effectiveTime)
                                                              throws InvalidParameterException,
                                                                     UserNotAuthorizedException,
                                                                     PropertyServerException
```
    Retrieve the list of links to external glossary resources attached to a glossary.
    
    Parameters:
    
    glossaryGUID - unique identifier of the metadata element for the glossary of interest
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Returns:
    
    list of attached links to external glossary resources
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getGlossariesForExternalLink
```
public List<GlossaryElement> getGlossariesForExternalLink(String externalLinkGUID,
                                                          int startFrom,
                                                          int pageSize,
                                                          Date effectiveTime)
                                                   throws InvalidParameterException,
                                                          UserNotAuthorizedException,
                                                          PropertyServerException
```
    Return the glossaries connected to an external glossary source.
    
    Parameters:
    
    externalLinkGUID - unique identifier of the metadata element for the external glossary link of interest
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Returns:
    
    list of glossaries
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - attachExternalCategoryLink
```
public void attachExternalCategoryLink(String externalLinkGUID,
                                       String glossaryCategoryGUID,
                                       ExternalGlossaryElementLinkProperties linkProperties,
                                       Date effectiveTime)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException
```
    Create a link to an external glossary category resource. This is associated with a category to show that they have equivalent content. It is possible that this resource was generated from the glossary content or was the source for it.
    
    Parameters:
    
    externalLinkGUID - unique identifier of the external reference
    
    glossaryCategoryGUID - unique identifier for the glossary category
    
    linkProperties - properties of the link
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - detachExternalCategoryLink
```
public void detachExternalCategoryLink(String externalLinkGUID,
                                       String glossaryCategoryGUID,
                                       Date effectiveTime)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException
```
    Remove the link to an external glossary category resource.
    
    Parameters:
    
    externalLinkGUID - unique identifier of the external reference
    
    glossaryCategoryGUID - unique identifier for the glossary category
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - attachExternalTermLink
```
public void attachExternalTermLink(String externalLinkGUID,
                                   String glossaryTermGUID,
                                   ExternalGlossaryElementLinkProperties linkProperties,
                                   Date effectiveTime)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException
```
    Create a link to an external glossary term resource. This is associated with a term to show that they have equivalent content. It is possible that this resource was generated from the glossary content or was the source for it.
    
    Parameters:
    
    externalLinkGUID - unique identifier of the external reference
    
    glossaryTermGUID - unique identifier for the glossary category
    
    linkProperties - properties of the link
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - detachExternalTermLink
```
public void detachExternalTermLink(String externalLinkGUID,
                                   String glossaryTermGUID,
                                   Date effectiveTime)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException
```
    Remove the link to an external glossary term resource.
    
    Parameters:
    
    externalLinkGUID - unique identifier of the external reference
    
    glossaryTermGUID - unique identifier for the glossary category
    
    effectiveTime - the time that the retrieved elements must be effective for
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)

Class GlossaryExchangeService

Method Summary

Methods inherited from class java.lang.Object

Method Detail

isForLineage

setForLineage

isForDuplicateProcessing

setForDuplicateProcessing

createGlossary

createGlossaryFromTemplate

updateGlossary

removeGlossary

setGlossaryAsTaxonomy

clearGlossaryAsTaxonomy

setGlossaryAsCanonical

clearGlossaryAsCanonical

findGlossaries

getGlossariesByName

getGlossariesForAssetManager

getGlossaryByGUID

createGlossaryCategory

createGlossaryCategoryFromTemplate

updateGlossaryCategory

setupCategoryParent

clearCategoryParent

removeGlossaryCategory

findGlossaryCategories

getCategoriesForGlossary

getGlossaryCategoriesByName

getGlossaryCategoryByGUID

getGlossaryCategoryParent

getGlossarySubCategories

createGlossaryTerm

createControlledGlossaryTerm

createGlossaryTermFromTemplate

updateGlossaryTerm

updateGlossaryTermStatus

setupTermCategory

clearTermCategory

setupTermRelationship

updateTermRelationship

clearTermRelationship

setTermAsAbstractConcept

clearTermAsAbstractConcept

setTermAsDataValue

clearTermAsDataValue

setTermAsActivity

clearTermAsActivity

setTermAsContext

clearTermAsContext

setTermAsSpineObject

clearTermAsSpineObject

setTermAsSpineAttribute

clearTermAsSpineAttribute

setTermAsObjectIdentifier

clearTermAsObjectIdentifier

removeGlossaryTerm

findGlossaryTerms

getTermsForGlossary

getTermsForGlossaryCategory

getGlossaryTermsByName

getGlossaryTermByGUID

createExternalGlossaryLink

updateExternalGlossaryLink

removeExternalGlossaryLink

attachExternalLinkToGlossary

detachExternalLinkFromGlossary

getExternalLinksForGlossary

getGlossariesForExternalLink

attachExternalCategoryLink

detachExternalCategoryLink

attachExternalTermLink

detachExternalTermLink