SubjectAreaRelationship (Subject Area OMAS Client 1.2 API)

All Known Implementing Classes:

SubjectAreaRelationshipImpl
```
public interface SubjectAreaRelationship
```
The SubjectAreaDefinition Open Metadata Access Service (OMAS) API for relationships.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`Antonym`	`createAntonymRelationship(String serverName, String userId, Antonym antonym)` Create a antonym relationship.
`CategoryAnchorRelationship`	`createCategoryAnchorRelationship(String serverName, String userId, CategoryAnchorRelationship categoryAnchorRelationship)` Create a Category Anchor Relationship.
`ISARelationship`	`createIsaRelationship(String serverName, String userId, ISARelationship isa)` Create a Isa relationship, which is link between a more general glossary term and a more specific definition.
`PreferredTerm`	`createPreferredTermRelationship(String serverName, String userId, PreferredTerm preferredTerm)` Create a PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
`ProjectScopeRelationship`	`createProjectScopeRelationship(String serverName, String userId, ProjectScopeRelationship projectScope)` Create a ProjectScope relationship.
`RelatedTerm`	`createRelatedTerm(String serverName, String userId, RelatedTerm relatedTermRelationship)` Create a RelatedTerm.
`ReplacementTerm`	`createReplacementTermRelationship(String serverName, String userId, ReplacementTerm replacementTerm)` Create a ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
`Synonym`	`createSynonymRelationship(String serverName, String userId, Synonym synonym)` Create a synonym relationship.
`TermAnchorRelationship`	`createTermAnchorRelationship(String serverName, String userId, TermAnchorRelationship termAnchorRelationship)` Create a Term Anchor Relationship.
`TermCategorizationRelationship`	`createTermCategorizationRelationship(String serverName, String userId, TermCategorizationRelationship termCategorizationRelationship)` Create a Term Categorization Relationship.
`TermHASARelationship`	`createTermHASARelationship(String serverName, String userId, TermHASARelationship termHASARelationship)` Create a Term HASA Relationship.
`TermISATypeOFRelationship`	`createTermISATypeOFRelationship(String serverName, String userId, TermISATypeOFRelationship TermISATypeOFRelationship)` Create a TermISATypeOFRelationship relationship, which is defines an inheritance relationship between two spine objects.
`TermTYPEDBYRelationship`	`createTermTYPEDBYRelationship(String serverName, String userId, TermTYPEDBYRelationship termTYPEDBYRelationship)` Create a TermTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
`Translation`	`createTranslationRelationship(String serverName, String userId, Translation translation)` Create a Translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
`UsedInContext`	`createUsedInContextRelationship(String serverName, String userId, UsedInContext usedInContext)` Create a UsedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
`ValidValue`	`createValidValueRelationship(String serverName, String userId, ValidValue validValue)` Create a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
`Antonym`	`deleteAntonymRelationship(String serverName, String userId, String guid)` Delete a antonym relationship.
`CategoryAnchorRelationship`	`deleteCategoryAnchorRelationship(String serverName, String userId, String guid)` Delete a Category Anchor Relationship.
`ISARelationship`	`deleteIsaRelationship(String serverName, String userId, String guid)` Delete a isa relationship, which is link between a more general glossary term and a more specific definition.
`PreferredTerm`	`deletePreferredTermRelationship(String serverName, String userId, String guid)` Delete a preferredTerm relationship, which is link to an alternative term that the organization prefer is used.
`ProjectScopeRelationship`	`deleteProjectScopeRelationship(String serverName, String userId, String guid)` Delete a ProjectScope relationship.
`RelatedTerm`	`deleteRelatedTerm(String serverName, String userId, String guid)` Delete a RelatedTerm.
`ReplacementTerm`	`deleteReplacementTermRelationship(String serverName, String userId, String guid)` Delete a replacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
`Synonym`	`deleteSynonymRelationship(String serverName, String userId, String guid)` Delete a synonym relationship.
`TermAnchorRelationship`	`deleteTermAnchorRelationship(String serverName, String userId, String guid)` Delete a Term Anchor Relationship.
`TermCategorizationRelationship`	`deleteTermCategorizationRelationship(String serverName, String userId, String guid)` Delete a Term Categorization Relationship.
`TermHASARelationship`	`deleteTermHASARelationship(String serverName, String userId, String guid)` Delete a Term HASA Relationship.
`TermISATypeOFRelationship`	`deleteTermISATypeOFRelationship(String serverName, String userId, String guid)` Delete a TermISATypeOFRelationship relationship, which is defines an inheritance relationship between two spine objects.
`TermTYPEDBYRelationship`	`deleteTermTYPEDBYRelationship(String serverName, String userId, String guid)` Delete a termTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
`Translation`	`deleteTranslationRelationship(String serverName, String userId, String guid)` Delete a translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
`UsedInContext`	`deleteUsedInContextRelationship(String serverName, String userId, String guid)` Delete a usedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
`ValidValue`	`deleteValidValueRelationship(String serverName, String userId, String guid)` Delete a validValue relationship, which is link between glossary terms where one defines one of the data values for the another.
`Antonym`	`getAntonymRelationship(String serverName, String userId, String guid)` Get a antonym relationship.
`CategoryAnchorRelationship`	`getCategoryAnchorRelationship(String serverName, String userId, String guid)` Get a Category Anchor Relationship.
`ISARelationship`	`getIsaRelationship(String serverName, String userId, String guid)` Get a isa relationship, which is link between a more general glossary term and a more specific definition.
`PreferredTerm`	`getPreferredTermRelationship(String serverName, String userId, String guid)` Get a preferredTerm relationship, which is link to an alternative term that the organization prefer is used.
`ProjectScopeRelationship`	`getProjectScopeRelationship(String serverName, String userId, String guid)` Get a ProjectScope relationship.
`RelatedTerm`	`getRelatedTerm(String serverName, String userId, String guid)` Get a RelatedTerm.
`ReplacementTerm`	`getReplacementTermRelationship(String serverName, String userId, String guid)` Get a replacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
`SemanticAssignment`	`getSemanticAssignmentRelationship(String serverName, String userId, String guid)` Get a SemanticAssignment relationship, Links a glossary term to another element such as an asset or schema element to define its meaning.
`Synonym`	`getSynonymRelationship(String serverName, String userId, String guid)` Get a synonym relationship.
`TermAnchorRelationship`	`getTermAnchorRelationship(String serverName, String userId, String guid)` Get a Term Anchor Relationship.
`TermCategorizationRelationship`	`getTermCategorizationRelationship(String serverName, String userId, String guid)` Get a Term Categorization Relationship.
`TermHASARelationship`	`getTermHASARelationship(String serverName, String userId, String guid)` Get a Term HASA Relationship.
`TermISATypeOFRelationship`	`getTermISATypeOFRelationship(String serverName, String userId, String guid)` Get a TermISATypeOFRelationship relationship, which is defines an inheritance relationship between two spine objects.
`TermTYPEDBYRelationship`	`getTermTYPEDBYRelationship(String serverName, String userId, String guid)` Get a termTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
`Translation`	`getTranslationRelationship(String serverName, String userId, String guid)` Get a translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
`UsedInContext`	`getUsedInContextRelationship(String serverName, String userId, String guid)` Get a usedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
`ValidValue`	`getValidValueRelationship(String serverName, String userId, String guid)` Get a validValue relationship, which is link between glossary terms where one defines one of the data values for the another.
`void`	`purgeAntonymRelationship(String serverName, String userId, String guid)` Purge a antonym relationship.
`void`	`purgeCategoryAnchorRelationship(String serverName, String userId, String guid)` Purge a Category Anchor Relationship.
`void`	`purgeIsaRelationship(String serverName, String userId, String guid)` Purge a isa relationship, which is link between a more general glossary term and a more specific definition.
`void`	`purgePreferredTermRelationship(String serverName, String userId, String guid)` Purge a preferredTerm relationship, which is link to an alternative term that the organization prefer is used.
`void`	`purgeProjectScopeRelationship(String serverName, String userId, String guid)` Purge a ProjectScope relationship.
`void`	`purgeRelatedTerm(String serverName, String userId, String guid)` Purge a RelatedTerm.
`void`	`purgeReplacementTermRelationship(String serverName, String userId, String guid)` Purge a replacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
`void`	`purgeSynonymRelationship(String serverName, String userId, String guid)` Purge a synonym relationship.
`void`	`purgeTermAnchorRelationship(String serverName, String userId, String guid)` Purge a Term Anchor Relationship.
`void`	`purgeTermCategorizationRelationship(String serverName, String userId, String guid)` Purge a Term Categorization Relationship.
`void`	`purgeTermHASARelationship(String serverName, String userId, String guid)` Purge a Term HASA Relationship.
`void`	`purgeTermISATypeOFRelationship(String serverName, String userId, String guid)` Purge a TermISATypeOFRelationship relationship, which is defines an inheritance relationship between two spine objects.
`void`	`purgeTermTYPEDBYRelationship(String serverName, String userId, String guid)` Purge a termTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
`void`	`purgeTranslationRelationship(String serverName, String userId, String guid)` Purge a translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
`void`	`purgeUsedInContextRelationship(String serverName, String userId, String guid)` Purge a usedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
`void`	`purgeValidValueRelationship(String serverName, String userId, String guid)` Purge a validValue relationship, which is link between glossary terms where one defines one of the data values for the another.
`Antonym`	`replaceAntonymRelationship(String serverName, String userId, Antonym antonymRelationship)` Replace an Antonym relationship which is a link between glossary terms that have the opposite meaning
`CategoryAnchorRelationship`	`replaceCategoryAnchorRelationship(String serverName, String userId, CategoryAnchorRelationship categoryAnchorRelationship)` Replace a Category Anhor Relationship.
`ISARelationship`	`replaceIsaRelationship(String serverName, String userId, ISARelationship isaRelationship)` Replace an Isa relationship, which is link between a more general glossary term and a more specific definition.
`PreferredTerm`	`replacePreferredTermRelationship(String serverName, String userId, PreferredTerm preferredTermRelationship)` Replace an PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
`ProjectScopeRelationship`	`replaceProjectScopeRelationship(String serverName, String userId, ProjectScopeRelationship ProjectScopeRelationship)` Replace a ProjectScope relationship which is a link between the project content and the project.
`RelatedTerm`	`replaceRelatedTerm(String serverName, String userId, RelatedTerm termRelatedTerm)` Replace an ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
`ReplacementTerm`	`replaceReplacementTermRelationship(String serverName, String userId, ReplacementTerm replacementTermRelationship)` Replace an ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
`Synonym`	`replaceSynonymRelationship(String serverName, String userId, Synonym synonymRelationship)` Replace a Synonym relationship which is a link between glossary terms that have the same meaning
`TermAnchorRelationship`	`replaceTermAnchorRelationship(String serverName, String userId, TermAnchorRelationship termAnchorRelationship)` Replace a Term HASA Relationship.
`TermCategorizationRelationship`	`replaceTermCategorizationRelationship(String serverName, String userId, TermCategorizationRelationship termCategorizationRelationship)` Replace a Term HASA Relationship.
`TermHASARelationship`	`replaceTermHASARelationship(String serverName, String userId, TermHASARelationship termHASARelationship)` Replace a Term HASA Relationship.
`TermISATypeOFRelationship`	`replaceTermISATypeOFRelationship(String serverName, String userId, TermISATypeOFRelationship TermISATypeOFRelationship)` Replace an TermISATypeOFRelationship relationship, which is defines an inheritance relationship between two spine objects.
`TermTYPEDBYRelationship`	`replaceTermTYPEDBYRelationship(String serverName, String userId, TermTYPEDBYRelationship termTYPEDBYRelationship)` Replace an TermTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
`Translation`	`replaceTranslationRelationship(String serverName, String userId, Translation translationRelationship)` Replace an Translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
`UsedInContext`	`replaceUsedInContextRelationship(String serverName, String userId, UsedInContext usedInContextRelationship)` Replace an UsedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
`ValidValue`	`replaceValidValueRelationship(String serverName, String userId, ValidValue validValueRelationship)` Replace an ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
`Antonym`	`restoreAntonymRelationship(String serverName, String userId, String guid)` Restore a Antonym relationship Restore allows the deleted Antonym relationship to be made active again.
`CategoryAnchorRelationship`	`restoreCategoryAnchorRelationship(String serverName, String userId, String guid)` Restore a Category Anchor Relationship.
`ISARelationship`	`restoreIsaRelationship(String serverName, String userId, String guid)` Restore an is a relationship Restore allows the deleted is a relationship to be made active again.
`TermISATypeOFRelationship`	`restoreIsaTypeOfRelationship(String serverName, String userId, String guid)` Restore an is a type of relationship Restore allows the deleted is a type of relationship to be made active again.
`PreferredTerm`	`restorePreferredTermRelationship(String serverName, String userId, String guid)` Restore a preferred term relationship Restore allows the deletedpreferred term relationship to be made active again.
`ProjectScopeRelationship`	`restoreProjectScopeRelationship(String serverName, String userId, String guid)` Restore a ProjectScope relationship which is a link between the project content and the project.
`RelatedTerm`	`restoreRelatedTerm(String serverName, String userId, String guid)` Restore a Related Term relationship Restore allows the deleted Synonym relationship to be made active again.
`RelatedTerm`	`restoreRelatedTermRelationship(String serverName, String userId, String guid)` Restore a related term relationship Restore allows the deleted related term relationship to be made active again.
`ReplacementTerm`	`restoreReplacementTermRelationship(String serverName, String userId, String guid)` Restore a replacement term relationship Restore allows the deleted replacement term relationship to be made active again.
`Synonym`	`restoreSynonymRelationship(String serverName, String userId, String guid)` Restore a Synonym relationship Restore allows the deleted Synonym relationship to be made active again.
`TermAnchorRelationship`	`restoreTermAnchorRelationship(String serverName, String userId, String guid)` Restore a Term Anchor Relationship.
`TermCategorizationRelationship`	`restoreTermCategorizationRelationship(String serverName, String userId, String guid)` Restore a Term Categorization Relationship.
`TermHASARelationship`	`restoreTermHASARelationship(String serverName, String userId, String guid)` Restore a has a relationship Restore allows the deleted has a relationship to be made active again.
`Translation`	`restoreTranslationRelationship(String serverName, String userId, String guid)` Restore a Translation relationship Restore allows the deleted Translation relationship to be made active again.
`TermTYPEDBYRelationship`	`restoreTypedByRelationship(String serverName, String userId, String guid)` Restore a typed by relationship Restore allows the deleted typed by relationship to be made active again.
`UsedInContext`	`restoreUsedInContextRelationship(String serverName, String userId, String guid)` Restore a Used in context relationship Restore allows the deletedUsed in context relationship to be made active again.
`ValidValue`	`restoreValidValueRelationship(String serverName, String userId, String guid)` Restore a valid value relationship Restore allows the deletedvalid value relationship to be made active again.
`Antonym`	`updateAntonymRelationship(String serverName, String userId, Antonym antonymRelationship)` Update a Antonym relationship which is a link between glossary terms that have the opposite meaning
`ISARelationship`	`updateIsaRelationship(String serverName, String userId, ISARelationship isaRelationship)` Update a Isa relationship, which is link between a more general glossary term and a more specific definition.
`PreferredTerm`	`updatePreferredTermRelationship(String serverName, String userId, PreferredTerm preferredTermRelationship)` Update a PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
`ProjectScopeRelationship`	`updateProjectScopeRelationship(String serverName, String userId, ProjectScopeRelationship projectScopeRelationship)` Update a ProjectScope relationship which is a link between the project content and the project.
`RelatedTerm`	`updateRelatedTerm(String serverName, String userId, RelatedTerm termRelatedTerm)` Update a RelatedTerm Relationship.
`ReplacementTerm`	`updateReplacementTermRelationship(String serverName, String userId, ReplacementTerm replacementTermRelationship)` Update a ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
`Synonym`	`updateSynonymRelationship(String serverName, String userId, Synonym synonymRelationship)` Update a Synonym relationship which is a link between glossary terms that have the same meaning
`TermCategorizationRelationship`	`updateTermCategorizationRelationship(String serverName, String userId, TermCategorizationRelationship termCategorizationRelationship)` Update a Term Categorization Relationship.
`TermHASARelationship`	`updateTermHASARelationship(String serverName, String userId, TermHASARelationship termHASARelationship)` Update a Term HASA Relationship.
`TermISATypeOFRelationship`	`updateTermISATypeOFRelationship(String serverName, String userId, TermISATypeOFRelationship TermISATypeOFRelationship)` Update a TermISATypeOFRelationship relationship, which is defines an inheritance relationship between two spine objects.
`TermTYPEDBYRelationship`	`updateTermTYPEDBYRelationship(String serverName, String userId, TermTYPEDBYRelationship termTYPEDBYRelationship)` Update a TermTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
`Translation`	`updateTranslationRelationship(String serverName, String userId, Translation translationRelationship)` Update a Translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
`UsedInContext`	`updateUsedInContextRelationship(String serverName, String userId, UsedInContext usedInContextRelationship)` Update a UsedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
`ValidValue`	`updateValidValueRelationship(String serverName, String userId, ValidValue validValueRelationship)` Update a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.

- Method Detail
  - createTermHASARelationship
```
TermHASARelationship createTermHASARelationship(String serverName,
                                                String userId,
                                                TermHASARelationship termHASARelationship)
                                         throws InvalidParameterException,
                                                UserNotAuthorizedException,
                                                MetadataServerUncontactableException,
                                                UnexpectedResponseException,
                                                UnrecognizedGUIDException
```
    Create a Term HASA Relationship. A relationship between a spine object and a spine attribute. Note that this method does not error if the relationship ends are not spine objects or spine attributes.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termHASARelationship - the HASA relationship
    
    Returns:
    
    the created term HASA relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getTermHASARelationship
```
TermHASARelationship getTermHASARelationship(String serverName,
                                             String userId,
                                             String guid)
                                      throws InvalidParameterException,
                                             MetadataServerUncontactableException,
                                             UserNotAuthorizedException,
                                             UnexpectedResponseException,
                                             UnrecognizedGUIDException
```
    Get a Term HASA Relationship. A relationship between a spine object and a spine attribute.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermHASARelationship relationship to get
    
    Returns:
    
    TermHASARelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - updateTermHASARelationship
```
TermHASARelationship updateTermHASARelationship(String serverName,
                                                String userId,
                                                TermHASARelationship termHASARelationship)
                                         throws InvalidParameterException,
                                                UserNotAuthorizedException,
                                                MetadataServerUncontactableException,
                                                UnexpectedResponseException,
                                                UnrecognizedGUIDException
```
    Update a Term HASA Relationship.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termHASARelationship - the HASA relationship
    
    Returns:
    
    the created term HASA relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replaceTermHASARelationship
```
TermHASARelationship replaceTermHASARelationship(String serverName,
                                                 String userId,
                                                 TermHASARelationship termHASARelationship)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 MetadataServerUncontactableException,
                                                 UnexpectedResponseException,
                                                 UnrecognizedGUIDException
```
    Replace a Term HASA Relationship.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termHASARelationship - the HASA relationship
    
    Returns:
    
    the created term HASA relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deleteTermHASARelationship
```
TermHASARelationship deleteTermHASARelationship(String serverName,
                                                String userId,
                                                String guid)
                                         throws InvalidParameterException,
                                                MetadataServerUncontactableException,
                                                UserNotAuthorizedException,
                                                UnrecognizedGUIDException,
                                                FunctionNotSupportedException,
                                                RelationshipNotDeletedException,
                                                UnexpectedResponseException
```
    Delete a Term HASA Relationship. A relationship between a spine object and a spine attribute. * A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermHASARelationship relationship to delete
    
    Returns:
    
    Deleted TermHASARelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgeTermHASARelationship
```
void purgeTermHASARelationship(String serverName,
                               String userId,
                               String guid)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               GUIDNotPurgedException,
                               UnrecognizedGUIDException,
                               MetadataServerUncontactableException,
                               UnexpectedResponseException
```
    Purge a Term HASA Relationship. A relationship between a spine object and a spine attribute. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermHASARelationship relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreTermHASARelationship
```
TermHASARelationship restoreTermHASARelationship(String serverName,
                                                 String userId,
                                                 String guid)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 MetadataServerUncontactableException,
                                                 UnexpectedResponseException,
                                                 UnrecognizedGUIDException
```
    Restore a has a relationship Restore allows the deleted has a relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the has a relationship to delete
    
    Returns:
    
    response which when successful contains the restored has a relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - createRelatedTerm
```
RelatedTerm createRelatedTerm(String serverName,
                              String userId,
                              RelatedTerm relatedTermRelationship)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              MetadataServerUncontactableException,
                              UnexpectedResponseException,
                              UnrecognizedGUIDException
```
    Create a RelatedTerm. A Related Term is a link between two similar Terms.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    relatedTermRelationship - the RelatedTerm relationship
    
    Returns:
    
    the created RelatedTerm relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getRelatedTerm
```
RelatedTerm getRelatedTerm(String serverName,
                           String userId,
                           String guid)
                    throws InvalidParameterException,
                           MetadataServerUncontactableException,
                           UserNotAuthorizedException,
                           UnexpectedResponseException,
                           UnrecognizedGUIDException
```
    Get a RelatedTerm. A Related Term is a link between two similar Terms.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to get
    
    Returns:
    
    RelatedTerm Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - updateRelatedTerm
```
RelatedTerm updateRelatedTerm(String serverName,
                              String userId,
                              RelatedTerm termRelatedTerm)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              MetadataServerUncontactableException,
                              UnexpectedResponseException,
                              UnrecognizedGUIDException
```
    Update a RelatedTerm Relationship.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termRelatedTerm - the RelatedTerm relationship
    
    Returns:
    
    the created term RelatedTerm relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replaceRelatedTerm
```
RelatedTerm replaceRelatedTerm(String serverName,
                               String userId,
                               RelatedTerm termRelatedTerm)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               MetadataServerUncontactableException,
                               UnexpectedResponseException,
                               UnrecognizedGUIDException
```
    Replace an ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termRelatedTerm - the replacement related term relationship
    
    Returns:
    
    ReplacementTerm replaced related Term relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreRelatedTerm
```
RelatedTerm restoreRelatedTerm(String serverName,
                               String userId,
                               String guid)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               MetadataServerUncontactableException,
                               UnexpectedResponseException,
                               UnrecognizedGUIDException
```
    Restore a Related Term relationship Restore allows the deleted Synonym relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the related term relationship to restore
    
    Returns:
    
    response which when successful contains the restored related term relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deleteRelatedTerm
```
RelatedTerm deleteRelatedTerm(String serverName,
                              String userId,
                              String guid)
                       throws InvalidParameterException,
                              MetadataServerUncontactableException,
                              UserNotAuthorizedException,
                              UnrecognizedGUIDException,
                              FunctionNotSupportedException,
                              RelationshipNotDeletedException,
                              UnexpectedResponseException
```
    Delete a RelatedTerm. A Related Term is a link between two similar Terms. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete
    
    Returns:
    
    deleted RelatedTerm Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgeRelatedTerm
```
void purgeRelatedTerm(String serverName,
                      String userId,
                      String guid)
               throws InvalidParameterException,
                      UserNotAuthorizedException,
                      GUIDNotPurgedException,
                      UnrecognizedGUIDException,
                      MetadataServerUncontactableException,
                      UnexpectedResponseException
```
    Purge a RelatedTerm. A Related Term is a link between two similar Terms. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreRelatedTermRelationship
```
RelatedTerm restoreRelatedTermRelationship(String serverName,
                                           String userId,
                                           String guid)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           MetadataServerUncontactableException,
                                           UnexpectedResponseException,
                                           UnrecognizedGUIDException
```
    Restore a related term relationship Restore allows the deleted related term relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the related term relationship to delete
    
    Returns:
    
    response which when successful contains the restored related term relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - createSynonymRelationship
```
Synonym createSynonymRelationship(String serverName,
                                  String userId,
                                  Synonym synonym)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  MetadataServerUncontactableException,
                                  UnexpectedResponseException,
                                  UnrecognizedGUIDException
```
    Create a synonym relationship. A link between glossary terms that have the same meaning.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    synonym - the Synonym relationship
    
    Returns:
    
    the created Synonym relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getSynonymRelationship
```
Synonym getSynonymRelationship(String serverName,
                               String userId,
                               String guid)
                        throws InvalidParameterException,
                               MetadataServerUncontactableException,
                               UserNotAuthorizedException,
                               UnexpectedResponseException,
                               UnrecognizedGUIDException
```
    Get a synonym relationship. A link between glossary terms that have the same meaning.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to get
    
    Returns:
    
    Synonym Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - updateSynonymRelationship
```
Synonym updateSynonymRelationship(String serverName,
                                  String userId,
                                  Synonym synonymRelationship)
                           throws InvalidParameterException,
                                  MetadataServerUncontactableException,
                                  UserNotAuthorizedException,
                                  UnexpectedResponseException,
                                  UnrecognizedGUIDException
```
    Update a Synonym relationship which is a link between glossary terms that have the same meaning
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    synonymRelationship - the Synonym relationship
    
    Returns:
    
    updated Synonym relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replaceSynonymRelationship
```
Synonym replaceSynonymRelationship(String serverName,
                                   String userId,
                                   Synonym synonymRelationship)
                            throws InvalidParameterException,
                                   MetadataServerUncontactableException,
                                   UserNotAuthorizedException,
                                   UnexpectedResponseException,
                                   UnrecognizedGUIDException
```
    Replace a Synonym relationship which is a link between glossary terms that have the same meaning
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    synonymRelationship - the Synonym relationship
    
    Returns:
    
    replaced synonym relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deleteSynonymRelationship
```
Synonym deleteSynonymRelationship(String serverName,
                                  String userId,
                                  String guid)
                           throws InvalidParameterException,
                                  MetadataServerUncontactableException,
                                  UnrecognizedGUIDException,
                                  UserNotAuthorizedException,
                                  FunctionNotSupportedException,
                                  RelationshipNotDeletedException,
                                  UnexpectedResponseException
```
    Delete a synonym relationship. A link between glossary terms that have the same meaning. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete
    
    Returns:
    
    deleted Synonym Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgeSynonymRelationship
```
void purgeSynonymRelationship(String serverName,
                              String userId,
                              String guid)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              GUIDNotPurgedException,
                              UnrecognizedGUIDException,
                              MetadataServerUncontactableException,
                              UnexpectedResponseException
```
    Purge a synonym relationship. A link between glossary terms that have the same meaning. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Synonym relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreSynonymRelationship
```
Synonym restoreSynonymRelationship(String serverName,
                                   String userId,
                                   String guid)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   MetadataServerUncontactableException,
                                   UnexpectedResponseException,
                                   UnrecognizedGUIDException
```
    Restore a Synonym relationship Restore allows the deleted Synonym relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Synonym relationship to delete
    
    Returns:
    
    response which when successful contains the restored Synonym relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - createAntonymRelationship
```
Antonym createAntonymRelationship(String serverName,
                                  String userId,
                                  Antonym antonym)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  MetadataServerUncontactableException,
                                  UnexpectedResponseException,
                                  UnrecognizedGUIDException
```
    Create a antonym relationship. A link between glossary terms that have the opposite meaning.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    antonym - the Antonym relationship
    
    Returns:
    
    the created antonym relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getAntonymRelationship
```
Antonym getAntonymRelationship(String serverName,
                               String userId,
                               String guid)
                        throws InvalidParameterException,
                               MetadataServerUncontactableException,
                               UserNotAuthorizedException,
                               UnexpectedResponseException,
                               UnrecognizedGUIDException
```
    Get a antonym relationship. A link between glossary terms that have the opposite meaning.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to get
    
    Returns:
    
    Antonym Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - updateAntonymRelationship
```
Antonym updateAntonymRelationship(String serverName,
                                  String userId,
                                  Antonym antonymRelationship)
                           throws InvalidParameterException,
                                  MetadataServerUncontactableException,
                                  UserNotAuthorizedException,
                                  UnexpectedResponseException,
                                  UnrecognizedGUIDException
```
    Update a Antonym relationship which is a link between glossary terms that have the opposite meaning
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    antonymRelationship - the Antonym relationship
    
    Returns:
    
    Antonym updated antonym Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replaceAntonymRelationship
```
Antonym replaceAntonymRelationship(String serverName,
                                   String userId,
                                   Antonym antonymRelationship)
                            throws InvalidParameterException,
                                   MetadataServerUncontactableException,
                                   UserNotAuthorizedException,
                                   UnexpectedResponseException,
                                   UnrecognizedGUIDException
```
    Replace an Antonym relationship which is a link between glossary terms that have the opposite meaning
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    antonymRelationship - the antonym relationship
    
    Returns:
    
    Antonym replaced antonym Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deleteAntonymRelationship
```
Antonym deleteAntonymRelationship(String serverName,
                                  String userId,
                                  String guid)
                           throws InvalidParameterException,
                                  MetadataServerUncontactableException,
                                  UserNotAuthorizedException,
                                  UnrecognizedGUIDException,
                                  FunctionNotSupportedException,
                                  RelationshipNotDeletedException,
                                  UnexpectedResponseException
```
    Delete a antonym relationship. A link between glossary terms that have the opposite meaning. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete
    
    Returns:
    
    deleted Antonym Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted. Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgeAntonymRelationship
```
void purgeAntonymRelationship(String serverName,
                              String userId,
                              String guid)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              GUIDNotPurgedException,
                              UnrecognizedGUIDException,
                              MetadataServerUncontactableException,
                              UnexpectedResponseException
```
    Purge a antonym relationship. A link between glossary terms that have the opposite meaning. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Antonym relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreAntonymRelationship
```
Antonym restoreAntonymRelationship(String serverName,
                                   String userId,
                                   String guid)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   MetadataServerUncontactableException,
                                   UnexpectedResponseException,
                                   UnrecognizedGUIDException
```
    Restore a Antonym relationship Restore allows the deleted Antonym relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Antonym relationship to delete
    
    Returns:
    
    response which when successful contains the restored Antonym relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - createTranslationRelationship
```
Translation createTranslationRelationship(String serverName,
                                          String userId,
                                          Translation translation)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          MetadataServerUncontactableException,
                                          UnexpectedResponseException,
                                          UnrecognizedGUIDException
```
    Create a Translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    translation - the Translation relationship
    
    Returns:
    
    the created translation relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getTranslationRelationship
```
Translation getTranslationRelationship(String serverName,
                                       String userId,
                                       String guid)
                                throws InvalidParameterException,
                                       MetadataServerUncontactableException,
                                       UserNotAuthorizedException,
                                       UnexpectedResponseException,
                                       UnrecognizedGUIDException
```
    Get a translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to get
    
    Returns:
    
    Translation Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - updateTranslationRelationship
```
Translation updateTranslationRelationship(String serverName,
                                          String userId,
                                          Translation translationRelationship)
                                   throws InvalidParameterException,
                                          MetadataServerUncontactableException,
                                          UserNotAuthorizedException,
                                          UnexpectedResponseException,
                                          UnrecognizedGUIDException
```
    Update a Translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    translationRelationship - the Translation relationship
    
    Returns:
    
    Translation updated translation Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replaceTranslationRelationship
```
Translation replaceTranslationRelationship(String serverName,
                                           String userId,
                                           Translation translationRelationship)
                                    throws InvalidParameterException,
                                           MetadataServerUncontactableException,
                                           UserNotAuthorizedException,
                                           UnexpectedResponseException,
                                           UnrecognizedGUIDException
```
    Replace an Translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    translationRelationship - the translation relationship
    
    Returns:
    
    Translation replaced translation Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deleteTranslationRelationship
```
Translation deleteTranslationRelationship(String serverName,
                                          String userId,
                                          String guid)
                                   throws InvalidParameterException,
                                          MetadataServerUncontactableException,
                                          UserNotAuthorizedException,
                                          UnrecognizedGUIDException,
                                          FunctionNotSupportedException,
                                          RelationshipNotDeletedException,
                                          UnexpectedResponseException
```
    Delete a translation relationship, which is link between glossary terms that provide different natural language translation of the same concept. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete
    
    Returns:
    
    deleted Translation Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted. Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgeTranslationRelationship
```
void purgeTranslationRelationship(String serverName,
                                  String userId,
                                  String guid)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  GUIDNotPurgedException,
                                  UnrecognizedGUIDException,
                                  MetadataServerUncontactableException,
                                  UnexpectedResponseException
```
    Purge a translation relationship, which is link between glossary terms that provide different natural language translation of the same concept. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Translation relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreTranslationRelationship
```
Translation restoreTranslationRelationship(String serverName,
                                           String userId,
                                           String guid)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           MetadataServerUncontactableException,
                                           UnexpectedResponseException,
                                           UnrecognizedGUIDException
```
    Restore a Translation relationship Restore allows the deleted Translation relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Translation relationship to delete
    
    Returns:
    
    response which when successful contains the restored Translation relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - createUsedInContextRelationship
```
UsedInContext createUsedInContextRelationship(String serverName,
                                              String userId,
                                              UsedInContext usedInContext)
                                       throws InvalidParameterException,
                                              UserNotAuthorizedException,
                                              MetadataServerUncontactableException,
                                              UnexpectedResponseException,
                                              UnrecognizedGUIDException
```
    Create a UsedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    usedInContext - the UsedInContext relationship
    
    Returns:
    
    the created usedInContext relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getUsedInContextRelationship
```
UsedInContext getUsedInContextRelationship(String serverName,
                                           String userId,
                                           String guid)
                                    throws InvalidParameterException,
                                           MetadataServerUncontactableException,
                                           UserNotAuthorizedException,
                                           UnexpectedResponseException,
                                           UnrecognizedGUIDException
```
    Get a usedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to get
    
    Returns:
    
    UsedInContext Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - updateUsedInContextRelationship
```
UsedInContext updateUsedInContextRelationship(String serverName,
                                              String userId,
                                              UsedInContext usedInContextRelationship)
                                       throws InvalidParameterException,
                                              MetadataServerUncontactableException,
                                              UserNotAuthorizedException,
                                              UnexpectedResponseException,
                                              UnrecognizedGUIDException
```
    Update a UsedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    usedInContextRelationship - the UsedInContext relationship
    
    Returns:
    
    UsedInContext updated usedInContext Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replaceUsedInContextRelationship
```
UsedInContext replaceUsedInContextRelationship(String serverName,
                                               String userId,
                                               UsedInContext usedInContextRelationship)
                                        throws InvalidParameterException,
                                               MetadataServerUncontactableException,
                                               UserNotAuthorizedException,
                                               UnexpectedResponseException,
                                               UnrecognizedGUIDException
```
    Replace an UsedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    usedInContextRelationship - the usedInContext relationship
    
    Returns:
    
    UsedInContext replaced usedInContext Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deleteUsedInContextRelationship
```
UsedInContext deleteUsedInContextRelationship(String serverName,
                                              String userId,
                                              String guid)
                                       throws InvalidParameterException,
                                              MetadataServerUncontactableException,
                                              UserNotAuthorizedException,
                                              UnrecognizedGUIDException,
                                              FunctionNotSupportedException,
                                              RelationshipNotDeletedException,
                                              UnexpectedResponseException
```
    Delete a usedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete
    
    Returns:
    
    deleted UsedInContext Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted. Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgeUsedInContextRelationship
```
void purgeUsedInContextRelationship(String serverName,
                                    String userId,
                                    String guid)
                             throws InvalidParameterException,
                                    UserNotAuthorizedException,
                                    GUIDNotPurgedException,
                                    UnrecognizedGUIDException,
                                    MetadataServerUncontactableException,
                                    UnexpectedResponseException
```
    Purge a usedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the UsedInContext relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreUsedInContextRelationship
```
UsedInContext restoreUsedInContextRelationship(String serverName,
                                               String userId,
                                               String guid)
                                        throws InvalidParameterException,
                                               UserNotAuthorizedException,
                                               MetadataServerUncontactableException,
                                               UnexpectedResponseException,
                                               UnrecognizedGUIDException
```
    Restore a Used in context relationship Restore allows the deletedUsed in context relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Used in context relationship to delete
    
    Returns:
    
    response which when successful contains the restored Used in context relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - createPreferredTermRelationship
```
PreferredTerm createPreferredTermRelationship(String serverName,
                                              String userId,
                                              PreferredTerm preferredTerm)
                                       throws InvalidParameterException,
                                              UserNotAuthorizedException,
                                              MetadataServerUncontactableException,
                                              UnexpectedResponseException,
                                              UnrecognizedGUIDException
```
    Create a PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    preferredTerm - the PreferredTerm relationship
    
    Returns:
    
    the created preferredTerm relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getPreferredTermRelationship
```
PreferredTerm getPreferredTermRelationship(String serverName,
                                           String userId,
                                           String guid)
                                    throws InvalidParameterException,
                                           MetadataServerUncontactableException,
                                           UserNotAuthorizedException,
                                           UnexpectedResponseException,
                                           UnrecognizedGUIDException
```
    Get a preferredTerm relationship, which is link to an alternative term that the organization prefer is used.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to get
    
    Returns:
    
    PreferredTerm Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - updatePreferredTermRelationship
```
PreferredTerm updatePreferredTermRelationship(String serverName,
                                              String userId,
                                              PreferredTerm preferredTermRelationship)
                                       throws InvalidParameterException,
                                              MetadataServerUncontactableException,
                                              UserNotAuthorizedException,
                                              UnexpectedResponseException,
                                              UnrecognizedGUIDException
```
    Update a PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    preferredTermRelationship - the PreferredTerm relationship
    
    Returns:
    
    PreferredTerm updated preferredTerm Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replacePreferredTermRelationship
```
PreferredTerm replacePreferredTermRelationship(String serverName,
                                               String userId,
                                               PreferredTerm preferredTermRelationship)
                                        throws InvalidParameterException,
                                               MetadataServerUncontactableException,
                                               UserNotAuthorizedException,
                                               UnexpectedResponseException,
                                               UnrecognizedGUIDException
```
    Replace an PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    preferredTermRelationship - the preferredTerm relationship
    
    Returns:
    
    PreferredTerm replaced preferredTerm Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deletePreferredTermRelationship
```
PreferredTerm deletePreferredTermRelationship(String serverName,
                                              String userId,
                                              String guid)
                                       throws InvalidParameterException,
                                              MetadataServerUncontactableException,
                                              UserNotAuthorizedException,
                                              UnrecognizedGUIDException,
                                              FunctionNotSupportedException,
                                              RelationshipNotDeletedException,
                                              UnexpectedResponseException
```
    Delete a preferredTerm relationship, which is link to an alternative term that the organization prefer is used. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete
    
    Returns:
    
    deleted PreferredTerm Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted. Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgePreferredTermRelationship
```
void purgePreferredTermRelationship(String serverName,
                                    String userId,
                                    String guid)
                             throws InvalidParameterException,
                                    UserNotAuthorizedException,
                                    GUIDNotPurgedException,
                                    UnrecognizedGUIDException,
                                    MetadataServerUncontactableException,
                                    UnexpectedResponseException
```
    Purge a preferredTerm relationship, which is link to an alternative term that the organization prefer is used. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the PreferredTerm relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restorePreferredTermRelationship
```
PreferredTerm restorePreferredTermRelationship(String serverName,
                                               String userId,
                                               String guid)
                                        throws InvalidParameterException,
                                               UserNotAuthorizedException,
                                               MetadataServerUncontactableException,
                                               UnexpectedResponseException,
                                               UnrecognizedGUIDException
```
    Restore a preferred term relationship Restore allows the deletedpreferred term relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the preferred term relationship to delete
    
    Returns:
    
    response which when successful contains the restored preferred term relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - createValidValueRelationship
```
ValidValue createValidValueRelationship(String serverName,
                                        String userId,
                                        ValidValue validValue)
                                 throws InvalidParameterException,
                                        UserNotAuthorizedException,
                                        MetadataServerUncontactableException,
                                        UnexpectedResponseException,
                                        UnrecognizedGUIDException
```
    Create a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    validValue - the ValidValue relationship
    
    Returns:
    
    the created validValue relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getValidValueRelationship
```
ValidValue getValidValueRelationship(String serverName,
                                     String userId,
                                     String guid)
                              throws InvalidParameterException,
                                     MetadataServerUncontactableException,
                                     UserNotAuthorizedException,
                                     UnexpectedResponseException,
                                     UnrecognizedGUIDException
```
    Get a validValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to get
    
    Returns:
    
    ValidValue Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - updateValidValueRelationship
```
ValidValue updateValidValueRelationship(String serverName,
                                        String userId,
                                        ValidValue validValueRelationship)
                                 throws InvalidParameterException,
                                        MetadataServerUncontactableException,
                                        UserNotAuthorizedException,
                                        UnexpectedResponseException,
                                        UnrecognizedGUIDException
```
    Update a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    validValueRelationship - the ValidValue relationship
    
    Returns:
    
    ValidValue updated validValue Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replaceValidValueRelationship
```
ValidValue replaceValidValueRelationship(String serverName,
                                         String userId,
                                         ValidValue validValueRelationship)
                                  throws InvalidParameterException,
                                         MetadataServerUncontactableException,
                                         UserNotAuthorizedException,
                                         UnexpectedResponseException,
                                         UnrecognizedGUIDException
```
    Replace an ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    validValueRelationship - the validValue relationship
    
    Returns:
    
    ValidValue replaced validValue Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deleteValidValueRelationship
```
ValidValue deleteValidValueRelationship(String serverName,
                                        String userId,
                                        String guid)
                                 throws InvalidParameterException,
                                        MetadataServerUncontactableException,
                                        UserNotAuthorizedException,
                                        UnrecognizedGUIDException,
                                        FunctionNotSupportedException,
                                        RelationshipNotDeletedException,
                                        UnexpectedResponseException
```
    Delete a validValue relationship, which is link between glossary terms where one defines one of the data values for the another. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete
    
    Returns:
    
    deleted ValidValue Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted. Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgeValidValueRelationship
```
void purgeValidValueRelationship(String serverName,
                                 String userId,
                                 String guid)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 GUIDNotPurgedException,
                                 UnrecognizedGUIDException,
                                 MetadataServerUncontactableException,
                                 UnexpectedResponseException
```
    Purge a validValue relationship, which is link between glossary terms where one defines one of the data values for the another. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ValidValue relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreValidValueRelationship
```
ValidValue restoreValidValueRelationship(String serverName,
                                         String userId,
                                         String guid)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         MetadataServerUncontactableException,
                                         UnexpectedResponseException,
                                         UnrecognizedGUIDException
```
    Restore a valid value relationship Restore allows the deletedvalid value relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the valid value relationship to delete
    
    Returns:
    
    response which when successful contains the restored valid value relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - createReplacementTermRelationship
```
ReplacementTerm createReplacementTermRelationship(String serverName,
                                                  String userId,
                                                  ReplacementTerm replacementTerm)
                                           throws InvalidParameterException,
                                                  UserNotAuthorizedException,
                                                  MetadataServerUncontactableException,
                                                  UnexpectedResponseException,
                                                  UnrecognizedGUIDException
```
    Create a ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    replacementTerm - the ReplacementTerm relationship
    
    Returns:
    
    the created replacementTerm relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getReplacementTermRelationship
```
ReplacementTerm getReplacementTermRelationship(String serverName,
                                               String userId,
                                               String guid)
                                        throws InvalidParameterException,
                                               MetadataServerUncontactableException,
                                               UserNotAuthorizedException,
                                               UnexpectedResponseException,
                                               UnrecognizedGUIDException
```
    Get a replacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to get
    
    Returns:
    
    ReplacementTerm Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - updateReplacementTermRelationship
```
ReplacementTerm updateReplacementTermRelationship(String serverName,
                                                  String userId,
                                                  ReplacementTerm replacementTermRelationship)
                                           throws InvalidParameterException,
                                                  MetadataServerUncontactableException,
                                                  UserNotAuthorizedException,
                                                  UnexpectedResponseException,
                                                  UnrecognizedGUIDException
```
    Update a ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    replacementTermRelationship - the ReplacementTerm relationship
    
    Returns:
    
    ReplacementTerm updated replacementTerm Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replaceReplacementTermRelationship
```
ReplacementTerm replaceReplacementTermRelationship(String serverName,
                                                   String userId,
                                                   ReplacementTerm replacementTermRelationship)
                                            throws InvalidParameterException,
                                                   MetadataServerUncontactableException,
                                                   UserNotAuthorizedException,
                                                   UnexpectedResponseException,
                                                   UnrecognizedGUIDException
```
    Replace an ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    replacementTermRelationship - the replacementTerm relationship
    
    Returns:
    
    ReplacementTerm replaced replacementTerm Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deleteReplacementTermRelationship
```
ReplacementTerm deleteReplacementTermRelationship(String serverName,
                                                  String userId,
                                                  String guid)
                                           throws InvalidParameterException,
                                                  MetadataServerUncontactableException,
                                                  UserNotAuthorizedException,
                                                  UnrecognizedGUIDException,
                                                  FunctionNotSupportedException,
                                                  RelationshipNotDeletedException,
                                                  UnexpectedResponseException
```
    Delete a replacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete
    
    Returns:
    
    deleted ReplacementTerm Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted. Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgeReplacementTermRelationship
```
void purgeReplacementTermRelationship(String serverName,
                                      String userId,
                                      String guid)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      GUIDNotPurgedException,
                                      UnrecognizedGUIDException,
                                      MetadataServerUncontactableException,
                                      UnexpectedResponseException
```
    Purge a replacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ReplacementTerm relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreReplacementTermRelationship
```
ReplacementTerm restoreReplacementTermRelationship(String serverName,
                                                   String userId,
                                                   String guid)
                                            throws InvalidParameterException,
                                                   UserNotAuthorizedException,
                                                   MetadataServerUncontactableException,
                                                   UnexpectedResponseException,
                                                   UnrecognizedGUIDException
```
    Restore a replacement term relationship Restore allows the deleted replacement term relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the replacement term relationship to delete
    
    Returns:
    
    response which when successful contains the restored replacement term relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - createTermTYPEDBYRelationship
```
TermTYPEDBYRelationship createTermTYPEDBYRelationship(String serverName,
                                                      String userId,
                                                      TermTYPEDBYRelationship termTYPEDBYRelationship)
                                               throws InvalidParameterException,
                                                      UserNotAuthorizedException,
                                                      MetadataServerUncontactableException,
                                                      UnexpectedResponseException,
                                                      UnrecognizedGUIDException
```
    Create a TermTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termTYPEDBYRelationship - the TermTYPEDBYRelationship relationship
    
    Returns:
    
    the created termTYPEDBYRelationship relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getTermTYPEDBYRelationship
```
TermTYPEDBYRelationship getTermTYPEDBYRelationship(String serverName,
                                                   String userId,
                                                   String guid)
                                            throws InvalidParameterException,
                                                   MetadataServerUncontactableException,
                                                   UserNotAuthorizedException,
                                                   UnexpectedResponseException,
                                                   UnrecognizedGUIDException
```
    Get a termTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to get
    
    Returns:
    
    TermTYPEDBYRelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - updateTermTYPEDBYRelationship
```
TermTYPEDBYRelationship updateTermTYPEDBYRelationship(String serverName,
                                                      String userId,
                                                      TermTYPEDBYRelationship termTYPEDBYRelationship)
                                               throws InvalidParameterException,
                                                      MetadataServerUncontactableException,
                                                      UserNotAuthorizedException,
                                                      UnexpectedResponseException,
                                                      UnrecognizedGUIDException
```
    Update a TermTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termTYPEDBYRelationship - the TermTYPEDBYRelationship relationship
    
    Returns:
    
    TermTYPEDBYRelationship updated termTYPEDBYRelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replaceTermTYPEDBYRelationship
```
TermTYPEDBYRelationship replaceTermTYPEDBYRelationship(String serverName,
                                                       String userId,
                                                       TermTYPEDBYRelationship termTYPEDBYRelationship)
                                                throws InvalidParameterException,
                                                       MetadataServerUncontactableException,
                                                       UserNotAuthorizedException,
                                                       UnexpectedResponseException,
                                                       UnrecognizedGUIDException
```
    Replace an TermTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termTYPEDBYRelationship - the termTYPEDBYRelationship relationship
    
    Returns:
    
    TermTYPEDBYRelationship replaced termTYPEDBYRelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deleteTermTYPEDBYRelationship
```
TermTYPEDBYRelationship deleteTermTYPEDBYRelationship(String serverName,
                                                      String userId,
                                                      String guid)
                                               throws InvalidParameterException,
                                                      MetadataServerUncontactableException,
                                                      UserNotAuthorizedException,
                                                      UnrecognizedGUIDException,
                                                      FunctionNotSupportedException,
                                                      RelationshipNotDeletedException,
                                                      UnexpectedResponseException
```
    Delete a termTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete
    
    Returns:
    
    deleted TermTYPEDBYRelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted. Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgeTermTYPEDBYRelationship
```
void purgeTermTYPEDBYRelationship(String serverName,
                                  String userId,
                                  String guid)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  GUIDNotPurgedException,
                                  UnrecognizedGUIDException,
                                  MetadataServerUncontactableException,
                                  UnexpectedResponseException
```
    Purge a termTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermTYPEDBYRelationship relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreTypedByRelationship
```
TermTYPEDBYRelationship restoreTypedByRelationship(String serverName,
                                                   String userId,
                                                   String guid)
                                            throws InvalidParameterException,
                                                   UserNotAuthorizedException,
                                                   MetadataServerUncontactableException,
                                                   UnexpectedResponseException,
                                                   UnrecognizedGUIDException
```
    Restore a typed by relationship Restore allows the deleted typed by relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the typed by relationship to delete
    
    Returns:
    
    response which when successful contains the restored typed by relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - createIsaRelationship
```
ISARelationship createIsaRelationship(String serverName,
                                      String userId,
                                      ISARelationship isa)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      MetadataServerUncontactableException,
                                      UnexpectedResponseException,
                                      UnrecognizedGUIDException
```
    Create a Isa relationship, which is link between a more general glossary term and a more specific definition.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    isa - the Isa relationship
    
    Returns:
    
    the created isa relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getIsaRelationship
```
ISARelationship getIsaRelationship(String serverName,
                                   String userId,
                                   String guid)
                            throws InvalidParameterException,
                                   MetadataServerUncontactableException,
                                   UserNotAuthorizedException,
                                   UnexpectedResponseException,
                                   UnrecognizedGUIDException
```
    Get a isa relationship, which is link between a more general glossary term and a more specific definition.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to get
    
    Returns:
    
    Isa Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - updateIsaRelationship
```
ISARelationship updateIsaRelationship(String serverName,
                                      String userId,
                                      ISARelationship isaRelationship)
                               throws InvalidParameterException,
                                      MetadataServerUncontactableException,
                                      UserNotAuthorizedException,
                                      UnexpectedResponseException,
                                      UnrecognizedGUIDException
```
    Update a Isa relationship, which is link between a more general glossary term and a more specific definition.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    isaRelationship - the Isa relationship
    
    Returns:
    
    Isa updated isa Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replaceIsaRelationship
```
ISARelationship replaceIsaRelationship(String serverName,
                                       String userId,
                                       ISARelationship isaRelationship)
                                throws InvalidParameterException,
                                       MetadataServerUncontactableException,
                                       UserNotAuthorizedException,
                                       UnexpectedResponseException,
                                       UnrecognizedGUIDException
```
    Replace an Isa relationship, which is link between a more general glossary term and a more specific definition.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    isaRelationship - the isa relationship
    
    Returns:
    
    Isa replaced isa Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deleteIsaRelationship
```
ISARelationship deleteIsaRelationship(String serverName,
                                      String userId,
                                      String guid)
                               throws InvalidParameterException,
                                      MetadataServerUncontactableException,
                                      UserNotAuthorizedException,
                                      UnrecognizedGUIDException,
                                      FunctionNotSupportedException,
                                      RelationshipNotDeletedException,
                                      UnexpectedResponseException
```
    Delete a isa relationship, which is link between a more general glossary term and a more specific definition. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete
    
    Returns:
    
    deleted Isa Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted. Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgeIsaRelationship
```
void purgeIsaRelationship(String serverName,
                          String userId,
                          String guid)
                   throws InvalidParameterException,
                          UserNotAuthorizedException,
                          GUIDNotPurgedException,
                          UnrecognizedGUIDException,
                          MetadataServerUncontactableException,
                          UnexpectedResponseException
```
    Purge a isa relationship, which is link between a more general glossary term and a more specific definition. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Isa relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreIsaRelationship
```
ISARelationship restoreIsaRelationship(String serverName,
                                       String userId,
                                       String guid)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       MetadataServerUncontactableException,
                                       UnexpectedResponseException,
                                       UnrecognizedGUIDException
```
    Restore an is a relationship Restore allows the deleted is a relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the is a relationship to delete
    
    Returns:
    
    response which when successful contains the restored is a relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - createTermISATypeOFRelationship
```
TermISATypeOFRelationship createTermISATypeOFRelationship(String serverName,
                                                          String userId,
                                                          TermISATypeOFRelationship TermISATypeOFRelationship)
                                                   throws InvalidParameterException,
                                                          UserNotAuthorizedException,
                                                          MetadataServerUncontactableException,
                                                          UnexpectedResponseException,
                                                          UnrecognizedGUIDException
```
    Create a TermISATypeOFRelationship relationship, which is defines an inheritance relationship between two spine objects.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    TermISATypeOFRelationship - the TermISATypeOFRelationship relationship
    
    Returns:
    
    the created TermISATypeOFRelationship relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getTermISATypeOFRelationship
```
TermISATypeOFRelationship getTermISATypeOFRelationship(String serverName,
                                                       String userId,
                                                       String guid)
                                                throws InvalidParameterException,
                                                       MetadataServerUncontactableException,
                                                       UserNotAuthorizedException,
                                                       UnexpectedResponseException,
                                                       UnrecognizedGUIDException
```
    Get a TermISATypeOFRelationship relationship, which is defines an inheritance relationship between two spine objects.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to get
    
    Returns:
    
    TermISATypeOFRelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - updateTermISATypeOFRelationship
```
TermISATypeOFRelationship updateTermISATypeOFRelationship(String serverName,
                                                          String userId,
                                                          TermISATypeOFRelationship TermISATypeOFRelationship)
                                                   throws InvalidParameterException,
                                                          MetadataServerUncontactableException,
                                                          UserNotAuthorizedException,
                                                          UnexpectedResponseException,
                                                          UnrecognizedGUIDException
```
    Update a TermISATypeOFRelationship relationship, which is defines an inheritance relationship between two spine objects.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    TermISATypeOFRelationship - the TermISATypeOFRelationship relationship
    
    Returns:
    
    TermISATypeOFRelationship updated TermISATypeOFRelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replaceTermISATypeOFRelationship
```
TermISATypeOFRelationship replaceTermISATypeOFRelationship(String serverName,
                                                           String userId,
                                                           TermISATypeOFRelationship TermISATypeOFRelationship)
                                                    throws InvalidParameterException,
                                                           MetadataServerUncontactableException,
                                                           UserNotAuthorizedException,
                                                           UnexpectedResponseException,
                                                           UnrecognizedGUIDException
```
    Replace an TermISATypeOFRelationship relationship, which is defines an inheritance relationship between two spine objects.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    TermISATypeOFRelationship - the TermISATypeOFRelationship relationship
    
    Returns:
    
    TermISATypeOFRelationship replaced TermISATypeOFRelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deleteTermISATypeOFRelationship
```
TermISATypeOFRelationship deleteTermISATypeOFRelationship(String serverName,
                                                          String userId,
                                                          String guid)
                                                   throws InvalidParameterException,
                                                          MetadataServerUncontactableException,
                                                          UserNotAuthorizedException,
                                                          UnrecognizedGUIDException,
                                                          FunctionNotSupportedException,
                                                          RelationshipNotDeletedException,
                                                          UnexpectedResponseException
```
    Delete a TermISATypeOFRelationship relationship, which is defines an inheritance relationship between two spine objects. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete
    
    Returns:
    
    deleted TermISATypeOFRelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted. Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgeTermISATypeOFRelationship
```
void purgeTermISATypeOFRelationship(String serverName,
                                    String userId,
                                    String guid)
                             throws InvalidParameterException,
                                    UserNotAuthorizedException,
                                    GUIDNotPurgedException,
                                    UnrecognizedGUIDException,
                                    MetadataServerUncontactableException,
                                    UnexpectedResponseException
```
    Purge a TermISATypeOFRelationship relationship, which is defines an inheritance relationship between two spine objects. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermISATypeOFRelationship relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreIsaTypeOfRelationship
```
TermISATypeOFRelationship restoreIsaTypeOfRelationship(String serverName,
                                                       String userId,
                                                       String guid)
                                                throws InvalidParameterException,
                                                       UserNotAuthorizedException,
                                                       MetadataServerUncontactableException,
                                                       UnexpectedResponseException,
                                                       UnrecognizedGUIDException
```
    Restore an is a type of relationship Restore allows the deleted is a type of relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the is a type of relationship to delete
    
    Returns:
    
    response which when successful contains the restored is a type of relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - createTermCategorizationRelationship
```
TermCategorizationRelationship createTermCategorizationRelationship(String serverName,
                                                                    String userId,
                                                                    TermCategorizationRelationship termCategorizationRelationship)
                                                             throws InvalidParameterException,
                                                                    UserNotAuthorizedException,
                                                                    MetadataServerUncontactableException,
                                                                    UnexpectedResponseException,
                                                                    UnrecognizedGUIDException
```
    Create a Term Categorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized. Note that this method does not error if the relationship ends are not spine objects or spine attributes.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termCategorizationRelationship - the term categorization relationship
    
    Returns:
    
    the created term categorization relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getTermCategorizationRelationship
```
TermCategorizationRelationship getTermCategorizationRelationship(String serverName,
                                                                 String userId,
                                                                 String guid)
                                                          throws InvalidParameterException,
                                                                 MetadataServerUncontactableException,
                                                                 UserNotAuthorizedException,
                                                                 UnexpectedResponseException,
                                                                 UnrecognizedGUIDException
```
    Get a Term Categorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermCategorizationRelationship relationship to get
    
    Returns:
    
    TermCategorizationRelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - updateTermCategorizationRelationship
```
TermCategorizationRelationship updateTermCategorizationRelationship(String serverName,
                                                                    String userId,
                                                                    TermCategorizationRelationship termCategorizationRelationship)
                                                             throws InvalidParameterException,
                                                                    UserNotAuthorizedException,
                                                                    MetadataServerUncontactableException,
                                                                    UnexpectedResponseException,
                                                                    UnrecognizedGUIDException
```
    Update a Term Categorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termCategorizationRelationship - the term categorization relationship
    
    Returns:
    
    the created term categorization relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replaceTermCategorizationRelationship
```
TermCategorizationRelationship replaceTermCategorizationRelationship(String serverName,
                                                                     String userId,
                                                                     TermCategorizationRelationship termCategorizationRelationship)
                                                              throws InvalidParameterException,
                                                                     UserNotAuthorizedException,
                                                                     MetadataServerUncontactableException,
                                                                     UnexpectedResponseException,
                                                                     UnrecognizedGUIDException
```
    Replace a Term HASA Relationship.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termCategorizationRelationship - the term categorization relationship
    
    Returns:
    
    the created term categorization relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deleteTermCategorizationRelationship
```
TermCategorizationRelationship deleteTermCategorizationRelationship(String serverName,
                                                                    String userId,
                                                                    String guid)
                                                             throws InvalidParameterException,
                                                                    MetadataServerUncontactableException,
                                                                    UserNotAuthorizedException,
                                                                    UnrecognizedGUIDException,
                                                                    FunctionNotSupportedException,
                                                                    RelationshipNotDeletedException,
                                                                    UnexpectedResponseException
```
    Delete a Term Categorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized. * A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermCategorizationRelationship relationship to delete
    
    Returns:
    
    Deleted TermCategorizationRelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgeTermCategorizationRelationship
```
void purgeTermCategorizationRelationship(String serverName,
                                         String userId,
                                         String guid)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         GUIDNotPurgedException,
                                         UnrecognizedGUIDException,
                                         MetadataServerUncontactableException,
                                         UnexpectedResponseException
```
    Purge a Term Categorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermCategorizationRelationship relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreTermCategorizationRelationship
```
TermCategorizationRelationship restoreTermCategorizationRelationship(String serverName,
                                                                     String userId,
                                                                     String guid)
                                                              throws InvalidParameterException,
                                                                     UserNotAuthorizedException,
                                                                     MetadataServerUncontactableException,
                                                                     UnexpectedResponseException,
                                                                     UnrecognizedGUIDException
```
    Restore a Term Categorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized. Restore allows the deleted Term Categorization relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Term Categorization relationship to delete
    
    Returns:
    
    response which when successful contains the restored has a relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - createTermAnchorRelationship
```
TermAnchorRelationship createTermAnchorRelationship(String serverName,
                                                    String userId,
                                                    TermAnchorRelationship termAnchorRelationship)
                                             throws InvalidParameterException,
                                                    UserNotAuthorizedException,
                                                    MetadataServerUncontactableException,
                                                    UnexpectedResponseException,
                                                    UnrecognizedGUIDException
```
    Create a Term Anchor Relationship. A relationship between a Glossary and a Term. This relationship allows terms to be owned by a glossary. This method does not error if the relationship ends are not spine objects or spine attributes. Terms created using the Subject Area OMAS cannot be created without a glossary and there can only be one glossary associated with a Term. This method is to allow glossaries to be associated with Terms that have not been created via the Subject Area OMAS or to recreate the TermAnchor relationship if it has been purged.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termAnchorRelationship - the TermAnchor relationship
    
    Returns:
    
    the created TermAnchor relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getTermAnchorRelationship
```
TermAnchorRelationship getTermAnchorRelationship(String serverName,
                                                 String userId,
                                                 String guid)
                                          throws InvalidParameterException,
                                                 MetadataServerUncontactableException,
                                                 UserNotAuthorizedException,
                                                 UnexpectedResponseException,
                                                 UnrecognizedGUIDException
```
    Get a Term Anchor Relationship. A relationship between a Glossary and a Term. This relationship allows terms to be owned by a glossary.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermAnchorRelationship relationship to get
    
    Returns:
    
    TermAnchorRelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replaceTermAnchorRelationship
```
TermAnchorRelationship replaceTermAnchorRelationship(String serverName,
                                                     String userId,
                                                     TermAnchorRelationship termAnchorRelationship)
                                              throws InvalidParameterException,
                                                     UserNotAuthorizedException,
                                                     MetadataServerUncontactableException,
                                                     UnexpectedResponseException,
                                                     UnrecognizedGUIDException
```
    Replace a Term HASA Relationship.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termAnchorRelationship - the TermAnchor relationship
    
    Returns:
    
    the updated TermAnchor relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deleteTermAnchorRelationship
```
TermAnchorRelationship deleteTermAnchorRelationship(String serverName,
                                                    String userId,
                                                    String guid)
                                             throws InvalidParameterException,
                                                    MetadataServerUncontactableException,
                                                    UserNotAuthorizedException,
                                                    UnrecognizedGUIDException,
                                                    FunctionNotSupportedException,
                                                    RelationshipNotDeletedException,
                                                    UnexpectedResponseException
```
    Delete a Term Anchor Relationship. A relationship between a Glossary and a Term. This relationship allows terms to be owned by a glossary. * A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermAnchorRelationship relationship to delete
    
    Returns:
    
    Deleted TermAnchorRelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgeTermAnchorRelationship
```
void purgeTermAnchorRelationship(String serverName,
                                 String userId,
                                 String guid)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 GUIDNotPurgedException,
                                 UnrecognizedGUIDException,
                                 MetadataServerUncontactableException,
                                 UnexpectedResponseException
```
    Purge a Term Anchor Relationship. A relationship between a Glossary and a Term. This relationship allows terms to be owned by a glossary. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermAnchorRelationship relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreTermAnchorRelationship
```
TermAnchorRelationship restoreTermAnchorRelationship(String serverName,
                                                     String userId,
                                                     String guid)
                                              throws InvalidParameterException,
                                                     UserNotAuthorizedException,
                                                     MetadataServerUncontactableException,
                                                     UnexpectedResponseException,
                                                     UnrecognizedGUIDException
```
    Restore a Term Anchor Relationship. A relationship between a Glossary and a Term. This relationship allows terms to be owned by a glossary. Restore allows the deleted Term Categorization relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Term Anchor relationship to delete
    
    Returns:
    
    response which when successful contains the restored Term Anchor relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - createCategoryAnchorRelationship
```
CategoryAnchorRelationship createCategoryAnchorRelationship(String serverName,
                                                            String userId,
                                                            CategoryAnchorRelationship categoryAnchorRelationship)
                                                     throws InvalidParameterException,
                                                            UserNotAuthorizedException,
                                                            MetadataServerUncontactableException,
                                                            UnexpectedResponseException,
                                                            UnrecognizedGUIDException
```
    Create a Category Anchor Relationship. A relationship between a Glossary and a Category. This relationship allows categoriess to be owned by a glossary. Categories created using the Subject Area OMAS cannot be created without a glossary and there can only be one glossary associated with a Category. This method is to allow glossaries to be associated with Categories that have not been created via the Subject Area OMAS or to recreate the CategoryAnchor relationship if it has been purged.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    categoryAnchorRelationship - the category anchor relationship
    
    Returns:
    
    the created term categorization relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getCategoryAnchorRelationship
```
CategoryAnchorRelationship getCategoryAnchorRelationship(String serverName,
                                                         String userId,
                                                         String guid)
                                                  throws InvalidParameterException,
                                                         MetadataServerUncontactableException,
                                                         UserNotAuthorizedException,
                                                         UnexpectedResponseException,
                                                         UnrecognizedGUIDException
```
    Get a Category Anchor Relationship. A relationship between a Glossary and a Category. This relationship allows categoriess to be owned by a glossary.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the CategoryAnchorRelationship relationship to get
    
    Returns:
    
    CategoryAnchorRelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replaceCategoryAnchorRelationship
```
CategoryAnchorRelationship replaceCategoryAnchorRelationship(String serverName,
                                                             String userId,
                                                             CategoryAnchorRelationship categoryAnchorRelationship)
                                                      throws InvalidParameterException,
                                                             UserNotAuthorizedException,
                                                             MetadataServerUncontactableException,
                                                             UnexpectedResponseException,
                                                             UnrecognizedGUIDException
```
    Replace a Category Anhor Relationship.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    categoryAnchorRelationship - the category anchor relationship
    
    Returns:
    
    the created category anchor relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deleteCategoryAnchorRelationship
```
CategoryAnchorRelationship deleteCategoryAnchorRelationship(String serverName,
                                                            String userId,
                                                            String guid)
                                                     throws InvalidParameterException,
                                                            MetadataServerUncontactableException,
                                                            UserNotAuthorizedException,
                                                            UnrecognizedGUIDException,
                                                            FunctionNotSupportedException,
                                                            RelationshipNotDeletedException,
                                                            UnexpectedResponseException
```
    Delete a Category Anchor Relationship. A relationship between a Glossary and a Category. This relationship allows categoriess to be owned by a glossary. * A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the CategoryAnchorRelationship relationship to delete
    
    Returns:
    
    Deleted CategoryAnchorRelationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgeCategoryAnchorRelationship
```
void purgeCategoryAnchorRelationship(String serverName,
                                     String userId,
                                     String guid)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     GUIDNotPurgedException,
                                     UnrecognizedGUIDException,
                                     MetadataServerUncontactableException,
                                     UnexpectedResponseException
```
    Purge a Category Anchor Relationship. A relationship between a Glossary and a Category. This relationship allows categoriess to be owned by a glossary. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the CategoryAnchorRelationship relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreCategoryAnchorRelationship
```
CategoryAnchorRelationship restoreCategoryAnchorRelationship(String serverName,
                                                             String userId,
                                                             String guid)
                                                      throws InvalidParameterException,
                                                             UserNotAuthorizedException,
                                                             MetadataServerUncontactableException,
                                                             UnexpectedResponseException,
                                                             UnrecognizedGUIDException
```
    Restore a Category Anchor Relationship. A relationship between a Glossary and a Category. This relationship allows categoriess to be owned by a glossary. Restore allows the deleted Category Anchor relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Category Anchor relationship to delete
    
    Returns:
    
    response which when successful contains the restored category anchor relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - createProjectScopeRelationship
```
ProjectScopeRelationship createProjectScopeRelationship(String serverName,
                                                        String userId,
                                                        ProjectScopeRelationship projectScope)
                                                 throws InvalidParameterException,
                                                        UserNotAuthorizedException,
                                                        MetadataServerUncontactableException,
                                                        UnexpectedResponseException,
                                                        UnrecognizedGUIDException
```
    Create a ProjectScope relationship. A link between the project content and the project.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    projectScope - the ProjectScope relationship
    
    Returns:
    
    the created ProjectScope relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getProjectScopeRelationship
```
ProjectScopeRelationship getProjectScopeRelationship(String serverName,
                                                     String userId,
                                                     String guid)
                                              throws InvalidParameterException,
                                                     MetadataServerUncontactableException,
                                                     UserNotAuthorizedException,
                                                     UnexpectedResponseException,
                                                     UnrecognizedGUIDException
```
    Get a ProjectScope relationship. A link between the project content and the project.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to get
    
    Returns:
    
    ProjectScope Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - updateProjectScopeRelationship
```
ProjectScopeRelationship updateProjectScopeRelationship(String serverName,
                                                        String userId,
                                                        ProjectScopeRelationship projectScopeRelationship)
                                                 throws InvalidParameterException,
                                                        MetadataServerUncontactableException,
                                                        UserNotAuthorizedException,
                                                        UnexpectedResponseException,
                                                        UnrecognizedGUIDException
```
    Update a ProjectScope relationship which is a link between the project content and the project.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    projectScopeRelationship - the ProjectScope relationship
    
    Returns:
    
    updated ProjectScope relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - replaceProjectScopeRelationship
```
ProjectScopeRelationship replaceProjectScopeRelationship(String serverName,
                                                         String userId,
                                                         ProjectScopeRelationship ProjectScopeRelationship)
                                                  throws InvalidParameterException,
                                                         MetadataServerUncontactableException,
                                                         UserNotAuthorizedException,
                                                         UnexpectedResponseException,
                                                         UnrecognizedGUIDException
```
    Replace a ProjectScope relationship which is a link between the project content and the project.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    ProjectScopeRelationship - the ProjectScope relationship
    
    Returns:
    
    replaced ProjectScope relationship Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - deleteProjectScopeRelationship
```
ProjectScopeRelationship deleteProjectScopeRelationship(String serverName,
                                                        String userId,
                                                        String guid)
                                                 throws InvalidParameterException,
                                                        MetadataServerUncontactableException,
                                                        UnrecognizedGUIDException,
                                                        UserNotAuthorizedException,
                                                        FunctionNotSupportedException,
                                                        RelationshipNotDeletedException,
                                                        UnexpectedResponseException
```
    Delete a ProjectScope relationship. A link between the project content and the project. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete
    
    Returns:
    
    deleted ProjectScope Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - purgeProjectScopeRelationship
```
void purgeProjectScopeRelationship(String serverName,
                                   String userId,
                                   String guid)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   GUIDNotPurgedException,
                                   UnrecognizedGUIDException,
                                   MetadataServerUncontactableException,
                                   UnexpectedResponseException
```
    Purge a ProjectScope relationship. A link between the project content and the project. A purge means that the relationship will not exist after the operation.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ProjectScope relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    GUIDNotPurgedException - a hard delete was issued but the relationship was not purged
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - restoreProjectScopeRelationship
```
ProjectScopeRelationship restoreProjectScopeRelationship(String serverName,
                                                         String userId,
                                                         String guid)
                                                  throws InvalidParameterException,
                                                         UserNotAuthorizedException,
                                                         MetadataServerUncontactableException,
                                                         UnexpectedResponseException,
                                                         UnrecognizedGUIDException
```
    Restore a ProjectScope relationship which is a link between the project content and the project. Restore allows the deleted ProjectScope relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ProjectScope relationship to restore
    
    Returns:
    
    response which when successful contains the restored ProjectScope relationship when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
  - getSemanticAssignmentRelationship
```
SemanticAssignment getSemanticAssignmentRelationship(String serverName,
                                                     String userId,
                                                     String guid)
                                              throws InvalidParameterException,
                                                     MetadataServerUncontactableException,
                                                     UserNotAuthorizedException,
                                                     UnexpectedResponseException,
                                                     UnrecognizedGUIDException
```
    Get a SemanticAssignment relationship, Links a glossary term to another element such as an asset or schema element to define its meaning.
    
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the SemanticAssignment relationship to get
    
    Returns:
    
    the SemanticAssignment relationship with the requested guid Exceptions returned by the server
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UnrecognizedGUIDException - the supplied guid was not recognised Client library Exceptions
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server

Interface SubjectAreaRelationship

Method Summary

Method Detail

createTermHASARelationship

getTermHASARelationship

updateTermHASARelationship

replaceTermHASARelationship

deleteTermHASARelationship

purgeTermHASARelationship

restoreTermHASARelationship

createRelatedTerm

getRelatedTerm

updateRelatedTerm

replaceRelatedTerm

restoreRelatedTerm

deleteRelatedTerm

purgeRelatedTerm

restoreRelatedTermRelationship

createSynonymRelationship

getSynonymRelationship

updateSynonymRelationship

replaceSynonymRelationship

deleteSynonymRelationship

purgeSynonymRelationship

restoreSynonymRelationship

createAntonymRelationship

getAntonymRelationship

updateAntonymRelationship

replaceAntonymRelationship

deleteAntonymRelationship

purgeAntonymRelationship

restoreAntonymRelationship

createTranslationRelationship

getTranslationRelationship

updateTranslationRelationship

replaceTranslationRelationship

deleteTranslationRelationship

purgeTranslationRelationship

restoreTranslationRelationship

createUsedInContextRelationship

getUsedInContextRelationship

updateUsedInContextRelationship

replaceUsedInContextRelationship

deleteUsedInContextRelationship

purgeUsedInContextRelationship

restoreUsedInContextRelationship

createPreferredTermRelationship

getPreferredTermRelationship

updatePreferredTermRelationship

replacePreferredTermRelationship

deletePreferredTermRelationship

purgePreferredTermRelationship

restorePreferredTermRelationship

createValidValueRelationship

getValidValueRelationship

updateValidValueRelationship

replaceValidValueRelationship

deleteValidValueRelationship

purgeValidValueRelationship

restoreValidValueRelationship

createReplacementTermRelationship

getReplacementTermRelationship

updateReplacementTermRelationship

replaceReplacementTermRelationship

deleteReplacementTermRelationship

purgeReplacementTermRelationship

restoreReplacementTermRelationship

createTermTYPEDBYRelationship

getTermTYPEDBYRelationship

updateTermTYPEDBYRelationship

replaceTermTYPEDBYRelationship

deleteTermTYPEDBYRelationship

purgeTermTYPEDBYRelationship

restoreTypedByRelationship

createIsaRelationship

getIsaRelationship

updateIsaRelationship

replaceIsaRelationship

deleteIsaRelationship

purgeIsaRelationship