SubjectAreaRelationshipImpl (Subject Area OMAS Client 2.0 API)

java.lang.Object
- org.odpi.openmetadata.commonservices.ffdc.rest.FFDCRESTClientBase
- - org.odpi.openmetadata.commonservices.ffdc.rest.FFDCRESTClient
  - - org.odpi.openmetadata.accessservices.subjectarea.client.SubjectAreaBaseImpl
    - - org.odpi.openmetadata.accessservices.subjectarea.client.SubjectAreaRelationshipImpl

All Implemented Interfaces:

SubjectAreaRelationship
```
public class SubjectAreaRelationshipImpl
extends SubjectAreaBaseImpl
implements SubjectAreaRelationship
```
SubjectAreaImpl is the OMAS client library implementation of the Subject Area OMAS. This interface provides relationship authoring interface for subject area experts.

Field Summary
- Fields inherited from class org.odpi.openmetadata.commonservices.ffdc.rest.FFDCRESTClientBase
  auditLog, exceptionHandler, serverName, serverPlatformURLRoot

Constructor Summary

Constructors
Constructor and Description

SubjectAreaRelationshipImpl(String serverName, String serverPlatformURLRoot)
Constructor for no authentication.

Constructors
Constructor and Description
`SubjectAreaRelationshipImpl(String serverName, String serverPlatformURLRoot)` Constructor for no authentication.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Antonym`	`createAntonymRelationship(String userId, Antonym antonym)` Create a antonym relationship.
`CategoryAnchor`	`createCategoryAnchorRelationship(String userId, CategoryAnchor categoryAnchor)` Create a Category Anchor Relationship.
`Isa`	`createIsaRelationship(String userId, Isa isa)` Create a Isa relationship, which is link between a more general glossary term and a more specific definition.
`PreferredTerm`	`createPreferredTermRelationship(String userId, PreferredTerm preferredTerm)` Create a PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
`ProjectScope`	`createProjectScopeRelationship(String userId, ProjectScope projectScope)` Create a ProjectScope relationship.
`RelatedTerm`	`createRelatedTerm(String userId, RelatedTerm relatedTermRelationship)` Create a RelatedTerm.
`ReplacementTerm`	`createReplacementTermRelationship(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 userId, Synonym synonym)` Create a synonym relationship.
`TermAnchor`	`createTermAnchorRelationship(String userId, TermAnchor termAnchor)` Create a Term Anchor Relationship.
`Categorization`	`createTermCategorizationRelationship(String userId, Categorization categorization)` Create a Term Categorization Relationship.
`Hasa`	`createTermHASARelationship(String userId, Hasa hasa)` Create a Term HASA Relationship.
`IsaTypeOf`	`createTermISATypeOFRelationship(String userId, IsaTypeOf isaTypeOf)` Create a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
`TypedBy`	`createTermTYPEDBYRelationship(String userId, TypedBy termTYPEDBYRelationship)` Create a TypedBy relationship, which is defines the relationship between a spine attribute and its type.
`Translation`	`createTranslationRelationship(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 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 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 userId, String guid)` Delete a antonym relationship.
`CategoryAnchor`	`deleteCategoryAnchorRelationship(String userId, String guid)` Delete a Category Anchor Relationship.
`Isa`	`deleteIsaRelationship(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 userId, String guid)` Delete a preferredTerm relationship, which is link to an alternative term that the organization prefer is used.
`ProjectScope`	`deleteProjectScopeRelationship(String userId, String guid)` Delete a ProjectScope relationship.
`RelatedTerm`	`deleteRelatedTerm(String userId, String guid)` Delete a RelatedTerm.
`ReplacementTerm`	`deleteReplacementTermRelationship(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 userId, String guid)` Delete a synonym relationship.
`TermAnchor`	`deleteTermAnchorRelationship(String userId, String guid)` Delete a Term Anchor Relationship.
`Categorization`	`deleteTermCategorizationRelationship(String userId, String guid)` Delete a Term Categorization Relationship.
`Hasa`	`deleteTermHASARelationship(String userId, String guid)` Delete a Term HASA Relationship.
`IsaTypeOf`	`deleteTermISATypeOFRelationship(String userId, String guid)` Delete a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
`TypedBy`	`deleteTermTYPEDBYRelationship(String userId, String guid)` Delete a termTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
`Translation`	`deleteTranslationRelationship(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 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 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 userId, String guid)` Get a antonym relationship.
`CategoryAnchor`	`getCategoryAnchorRelationship(String userId, String guid)` Get a Category Anchor Relationship.
`Isa`	`getIsaRelationship(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 userId, String guid)` Get a preferredTerm relationship, which is link to an alternative term that the organization prefer is used.
`ProjectScope`	`getProjectScopeRelationship(String userId, String guid)` Get a ProjectScope relationship.
`RelatedTerm`	`getRelatedTerm(String userId, String guid)` Get a RelatedTerm.
`ReplacementTerm`	`getReplacementTermRelationship(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 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 userId, String guid)` Get a synonym relationship.
`TermAnchor`	`getTermAnchorRelationship(String userId, String guid)` Get a Term Anchor Relationship.
`Categorization`	`getTermCategorizationRelationship(String userId, String guid)` Get a Term Categorization Relationship.
`Hasa`	`getTermHASARelationship(String userId, String guid)` Get a Term HASA Relationship.
`IsaTypeOf`	`getTermISATypeOFRelationship(String userId, String guid)` Get a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
`TypedBy`	`getTermTYPEDBYRelationship(String userId, String guid)` Get a termTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
`Translation`	`getTranslationRelationship(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 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 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 userId, String guid)` Purge a antonym relationship.
`void`	`purgeCategoryAnchorRelationship(String userId, String guid)` Purge a Category Anchor Relationship.
`void`	`purgeIsaRelationship(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 userId, String guid)` Purge a preferredTerm relationship, which is link to an alternative term that the organization prefer is used.
`void`	`purgeProjectScopeRelationship(String userId, String guid)` Purge a ProjectScope relationship.
`void`	`purgeRelatedTerm(String userId, String guid)` Purge a RelatedTerm.
`void`	`purgeReplacementTermRelationship(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 userId, String guid)` Purge a synonym relationship.
`void`	`purgeTermAnchorRelationship(String userId, String guid)` Purge a Term Anchor Relationship.
`void`	`purgeTermCategorizationRelationship(String userId, String guid)` Purge a Term Categorization Relationship.
`void`	`purgeTermHASARelationship(String userId, String guid)` Purge a Term HASA Relationship.
`void`	`purgeTermISATypeOFRelationship(String userId, String guid)` Purge a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
`void`	`purgeTermTYPEDBYRelationship(String userId, String guid)` Purge a termTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
`void`	`purgeTranslationRelationship(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 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 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 userId, Antonym antonymRelationship)` Replace an Antonym relationship which is a link between glossary terms that have the opposite meaning
`CategoryAnchor`	`replaceCategoryAnchorRelationship(String userId, CategoryAnchor termCategorizationRelationship)` Replace a Category Anchor Relationship.
`Isa`	`replaceIsaRelationship(String userId, Isa isaRelationship)` Replace an Isa relationship, which is link between a more general glossary term and a more specific definition.
`PreferredTerm`	`replacePreferredTermRelationship(String userId, PreferredTerm preferredTermRelationship)` Replace an PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
`ProjectScope`	`replaceProjectScopeRelationship(String userId, ProjectScope projectScopeRelationship)` Replace a ProjectScope relationship which is a link between the project content and the project.
`RelatedTerm`	`replaceRelatedTerm(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 userId, ReplacementTerm replacementTermRelationship)` Replace an ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
`Synonym`	`replaceSynonymRelationship(String userId, Synonym synonymRelationship)` Replace a Synonym relationship which is a link between glossary terms that have the same meaning
`TermAnchor`	`replaceTermAnchorRelationship(String userId, TermAnchor termCategorizationRelationship)` Replace a Term HASA Relationship.
`Categorization`	`replaceTermCategorizationRelationship(String userId, Categorization termCategorizationRelationship)` Replace a Term HASA Relationship.
`Hasa`	`replaceTermHASARelationship(String userId, Hasa hasa)` Replace a Term HASA Relationship.
`IsaTypeOf`	`replaceTermISATypeOFRelationship(String userId, IsaTypeOf isATypeOf)` Replace an isATypeOf relationship, which is defines an inheritance relationship between two spine objects.
`TypedBy`	`replaceTermTYPEDBYRelationship(String userId, TypedBy termTYPEDBYRelationship)` Replace an TypedBy relationship, which is defines the relationship between a spine attribute and its type.
`Translation`	`replaceTranslationRelationship(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 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 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 userId, String guid)` Restore a Antonym relationship Restore allows the deleted Antonym relationship to be made active again.
`CategoryAnchor`	`restoreCategoryAnchorRelationship(String userId, String guid)` Restore a Category Anchor Relationship.
`Isa`	`restoreIsaRelationship(String userId, String guid)` Restore an is a relationship Restore allows the deleted is a relationship to be made active again.
`IsaTypeOf`	`restoreIsaTypeOfRelationship(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 userId, String guid)` Restore a preferred term relationship Restore allows the deleted preferred term relationship to be made active again.
`ProjectScope`	`restoreProjectScopeRelationship(String userId, String guid)` Restore a ProjectScope relationship which is a link between the project content and the project.
`RelatedTerm`	`restoreRelatedTerm(String userId, String guid)` Restore a Related Term relationship Restore allows the deleted Related Term relationship to be made active again.
`ReplacementTerm`	`restoreReplacementTermRelationship(String userId, String guid)` Restore a replacement term relationship Restore allows the deleted replacement term relationship to be made active again.
`Synonym`	`restoreSynonymRelationship(String userId, String guid)` Restore a Synonym relationship Restore allows the deleted Synonym relationship to be made active again.
`TermAnchor`	`restoreTermAnchorRelationship(String userId, String guid)` Restore a Term Anchor Relationship.
`Categorization`	`restoreTermCategorizationRelationship(String userId, String guid)` Restore a Term Categorization Relationship.
`Hasa`	`restoreTermHASARelationship(String userId, String guid)` Restore a has a relationship Restore allows the deleted has a relationship to be made active again.
`Translation`	`restoreTranslationRelationship(String userId, String guid)` Restore a Translation relationship Restore allows the deleted Translation relationship to be made active again.
`TypedBy`	`restoreTypedByRelationship(String userId, String guid)` Restore a typed by relationship Restore allows the deleted typed by relationship to be made active again.
`UsedInContext`	`restoreUsedInContextRelationship(String userId, String guid)` Restore a Used in context relationship Restore allows the deleted Used in context relationship to be made active again.
`ValidValue`	`restoreValidValueRelationship(String userId, String guid)` Restore a valid value relationship Restore allows the deleted valid value relationship to be made active again.
`Antonym`	`updateAntonymRelationship(String userId, Antonym antonymRelationship)` Update a Antonym relationship which is a link between glossary terms that have the opposite meaning
`CategoryAnchor`	`updateCategoryAnchorRelationship(String userId, CategoryAnchor termCategorizationRelationship)` Update a Category Anchor Relationship.
`Isa`	`updateIsaRelationship(String userId, Isa isaRelationship)` Update a Isa relationship, which is link between a more general glossary term and a more specific definition.
`PreferredTerm`	`updatePreferredTermRelationship(String userId, PreferredTerm preferredTermRelationship)` Update a PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
`ProjectScope`	`updateProjectScopeRelationship(String userId, ProjectScope projectScopeRelationship)` Update a ProjectScope relationship which is a link between the project content and the project.
`RelatedTerm`	`updateRelatedTerm(String userId, RelatedTerm termRelatedTerm)` Update a RelatedTerm Relationship.
`ReplacementTerm`	`updateReplacementTermRelationship(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 userId, Synonym synonymRelationship)` Update a Synonym relationship which is a link between glossary terms that have the same meaning
`Categorization`	`updateTermCategorizationRelationship(String userId, Categorization termCategorizationRelationship)` Update a Term Categorization Relationship.
`Hasa`	`updateTermHASARelationship(String userId, Hasa hasa)` Update a Term HASA Relationship.
`IsaTypeOf`	`updateTermISATypeOFRelationship(String userId, IsaTypeOf isATypeOf)` Update a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
`TypedBy`	`updateTermTYPEDBYRelationship(String userId, TypedBy termTYPEDBYRelationship)` Update a TypedBy relationship, which is defines the relationship between a spine attribute and its type.
`Translation`	`updateTranslationRelationship(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 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 userId, ValidValue validValueRelationship)` Update a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.

Methods inherited from class org.odpi.openmetadata.accessservices.subjectarea.client.SubjectAreaBaseImpl
deleteEntityRESTCall, deleteRelationshipRESTCall, encodeQueryProperty, findRESTCall, getByIdRESTCall, getRelationships, postRESTCall, purgeEntityRESTCall, purgeRelationshipRESTCall, putRESTCall, restoreRESTCall

Methods inherited from class org.odpi.openmetadata.commonservices.ffdc.rest.FFDCRESTClient
callCountGetRESTCall, callGUIDGetRESTCall, callGUIDListGetRESTCall, callGUIDListPostRESTCall, callGUIDPostRESTCall, callNameListGetRESTCall, callStringMapGetRESTCall, callVoidGetRESTCall, callVoidPostRESTCall

Methods inherited from class org.odpi.openmetadata.commonservices.ffdc.rest.FFDCRESTClientBase
callDeleteRESTCall, callGetRESTCall, callGetRESTCallNoParams, callPostRESTCall, callPostRESTCallNoParams, callPutRESTCall

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

- Constructor Detail
  - SubjectAreaRelationshipImpl
```
public SubjectAreaRelationshipImpl(String serverName,
                                   String serverPlatformURLRoot)
                            throws InvalidParameterException
```
    Constructor for no authentication.
    
    Parameters:
    
    serverName - name of the OMAG Server to call
    
    serverPlatformURLRoot - URL root of the server platform where the OMAG Server is running.
    
    Throws:
    
    InvalidParameterException - there is a problem creating the client-side components to issue any REST API calls.
- Method Detail
  - createTermHASARelationship
```
public Hasa createTermHASARelationship(String userId,
                                       Hasa hasa)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       MetadataServerUncontactableException,
                                       UnexpectedResponseException,
                                       UnrecognizedGUIDException,
                                       PropertyServerException,
                                       FunctionNotSupportedException,
                                       PropertyServerException,
                                       FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    createTermHASARelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    hasa - the HASA relationship
    
    Returns:
    
    the created term HASA relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getTermHASARelationship
```
public Hasa getTermHASARelationship(String userId,
                                    String guid)
                             throws InvalidParameterException,
                                    MetadataServerUncontactableException,
                                    UserNotAuthorizedException,
                                    UnexpectedResponseException,
                                    UnrecognizedGUIDException,
                                    PropertyServerException,
                                    FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a Term HASA Relationship. A relationship between a spine object and a spine attribute.
    
    Specified by:
    
    getTermHASARelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Hasa relationship to get
    
    Returns:
    
    Hasa Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - updateTermHASARelationship
```
public Hasa updateTermHASARelationship(String userId,
                                       Hasa hasa)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       MetadataServerUncontactableException,
                                       UnexpectedResponseException,
                                       UnrecognizedGUIDException,
                                       PropertyServerException,
                                       FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Update a Term HASA Relationship.
    
    Specified by:
    
    updateTermHASARelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    hasa - the HASA relationship
    
    Returns:
    
    the updated term HASA relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - replaceTermHASARelationship
```
public Hasa replaceTermHASARelationship(String userId,
                                        Hasa hasa)
                                 throws InvalidParameterException,
                                        UserNotAuthorizedException,
                                        MetadataServerUncontactableException,
                                        UnexpectedResponseException,
                                        UnrecognizedGUIDException,
                                        PropertyServerException,
                                        FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace a Term HASA Relationship.
    
    Specified by:
    
    replaceTermHASARelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    hasa - the HASA relationship
    
    Returns:
    
    the replaced term HASA relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deleteTermHASARelationship
```
public Hasa deleteTermHASARelationship(String userId,
                                       String guid)
                                throws InvalidParameterException,
                                       MetadataServerUncontactableException,
                                       UserNotAuthorizedException,
                                       UnrecognizedGUIDException,
                                       FunctionNotSupportedException,
                                       RelationshipNotDeletedException,
                                       UnexpectedResponseException,
                                       PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    deleteTermHASARelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Hasa relationship to delete
    
    Returns:
    
    Deleted Hasa Exceptions returned by the server
    
    Throws:
    
    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.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception Client library Exceptions
  - purgeTermHASARelationship
```
public void purgeTermHASARelationship(String userId,
                                      String guid)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      UnrecognizedGUIDException,
                                      MetadataServerUncontactableException,
                                      UnexpectedResponseException,
                                      RelationshipNotPurgedException,
                                      FunctionNotSupportedException,
                                      PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    purgeTermHASARelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Hasa relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    FunctionNotSupportedException - function not supported Client library Exceptions
    
    PropertyServerException - property server exception
  - restoreTermHASARelationship
```
public Hasa restoreTermHASARelationship(String userId,
                                        String guid)
                                 throws InvalidParameterException,
                                        UserNotAuthorizedException,
                                        MetadataServerUncontactableException,
                                        UnexpectedResponseException,
                                        UnrecognizedGUIDException,
                                        PropertyServerException,
                                        FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    restoreTermHASARelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - createRelatedTerm
```
public RelatedTerm createRelatedTerm(String userId,
                                     RelatedTerm relatedTermRelationship)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     MetadataServerUncontactableException,
                                     UnexpectedResponseException,
                                     UnrecognizedGUIDException,
                                     PropertyServerException,
                                     FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Create a RelatedTerm. A Related Term is a link between two similar Terms.
    
    Specified by:
    
    createRelatedTerm in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getRelatedTerm
```
public RelatedTerm getRelatedTerm(String userId,
                                  String guid)
                           throws InvalidParameterException,
                                  MetadataServerUncontactableException,
                                  UserNotAuthorizedException,
                                  UnexpectedResponseException,
                                  UnrecognizedGUIDException,
                                  PropertyServerException,
                                  FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a RelatedTerm. A Related Term is a link between two similar Terms.
    
    Specified by:
    
    getRelatedTerm in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - updateRelatedTerm
```
public RelatedTerm updateRelatedTerm(String userId,
                                     RelatedTerm termRelatedTerm)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     MetadataServerUncontactableException,
                                     UnexpectedResponseException,
                                     UnrecognizedGUIDException,
                                     PropertyServerException,
                                     FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Update a RelatedTerm Relationship.
    
    Specified by:
    
    updateRelatedTerm in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    termRelatedTerm - the RelatedTerm relationship
    
    Returns:
    
    the updated term RelatedTerm relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - replaceRelatedTerm
```
public RelatedTerm replaceRelatedTerm(String userId,
                                      RelatedTerm termRelatedTerm)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      MetadataServerUncontactableException,
                                      UnexpectedResponseException,
                                      UnrecognizedGUIDException,
                                      PropertyServerException,
                                      FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace an ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
    
    Specified by:
    
    replaceRelatedTerm in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - restoreRelatedTerm
```
public RelatedTerm restoreRelatedTerm(String userId,
                                      String guid)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      MetadataServerUncontactableException,
                                      UnexpectedResponseException,
                                      UnrecognizedGUIDException,
                                      PropertyServerException,
                                      FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    restoreRelatedTerm in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deleteRelatedTerm
```
public RelatedTerm deleteRelatedTerm(String userId,
                                     String guid)
                              throws InvalidParameterException,
                                     MetadataServerUncontactableException,
                                     UserNotAuthorizedException,
                                     UnrecognizedGUIDException,
                                     FunctionNotSupportedException,
                                     RelationshipNotDeletedException,
                                     UnexpectedResponseException,
                                     PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    deleteRelatedTerm in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    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.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception Client library Exceptions
  - purgeRelatedTerm
```
public void purgeRelatedTerm(String userId,
                             String guid)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             UnrecognizedGUIDException,
                             MetadataServerUncontactableException,
                             UnexpectedResponseException,
                             RelationshipNotPurgedException,
                             PropertyServerException,
                             FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    purgeRelatedTerm in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - createSynonymRelationship
```
public Synonym createSynonymRelationship(String userId,
                                         Synonym synonym)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         MetadataServerUncontactableException,
                                         UnexpectedResponseException,
                                         UnrecognizedGUIDException,
                                         PropertyServerException,
                                         FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Create a synonym relationship. A link between glossary terms that have the same meaning.
    
    Specified by:
    
    createSynonymRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    synonym - the Synonym relationship
    
    Returns:
    
    the created Synonym relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getSynonymRelationship
```
public Synonym getSynonymRelationship(String userId,
                                      String guid)
                               throws InvalidParameterException,
                                      MetadataServerUncontactableException,
                                      UserNotAuthorizedException,
                                      UnexpectedResponseException,
                                      UnrecognizedGUIDException,
                                      PropertyServerException,
                                      FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a synonym relationship. A link between glossary terms that have the same meaning.
    
    Specified by:
    
    getSynonymRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - updateSynonymRelationship
```
public Synonym updateSynonymRelationship(String userId,
                                         Synonym synonymRelationship)
                                  throws InvalidParameterException,
                                         MetadataServerUncontactableException,
                                         UserNotAuthorizedException,
                                         UnexpectedResponseException,
                                         UnrecognizedGUIDException,
                                         PropertyServerException,
                                         FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Update a Synonym relationship which is a link between glossary terms that have the same meaning
    
    Specified by:
    
    updateSynonymRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    synonymRelationship - the Synonym relationship
    
    Returns:
    
    updated Synonym relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - replaceSynonymRelationship
```
public Synonym replaceSynonymRelationship(String userId,
                                          Synonym synonymRelationship)
                                   throws InvalidParameterException,
                                          MetadataServerUncontactableException,
                                          UserNotAuthorizedException,
                                          UnexpectedResponseException,
                                          UnrecognizedGUIDException,
                                          PropertyServerException,
                                          FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace a Synonym relationship which is a link between glossary terms that have the same meaning
    
    Specified by:
    
    replaceSynonymRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    synonymRelationship - the Synonym relationship
    
    Returns:
    
    replaced synonym relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deleteSynonymRelationship
```
public Synonym deleteSynonymRelationship(String userId,
                                         String guid)
                                  throws InvalidParameterException,
                                         MetadataServerUncontactableException,
                                         UnrecognizedGUIDException,
                                         UserNotAuthorizedException,
                                         FunctionNotSupportedException,
                                         RelationshipNotDeletedException,
                                         UnexpectedResponseException,
                                         PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    deleteSynonymRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    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.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    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.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception Client library Exceptions
  - purgeSynonymRelationship
```
public void purgeSynonymRelationship(String userId,
                                     String guid)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     UnrecognizedGUIDException,
                                     MetadataServerUncontactableException,
                                     UnexpectedResponseException,
                                     RelationshipNotPurgedException,
                                     PropertyServerException,
                                     FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    purgeSynonymRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - restoreSynonymRelationship
```
public Synonym restoreSynonymRelationship(String userId,
                                          String guid)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          MetadataServerUncontactableException,
                                          UnexpectedResponseException,
                                          UnrecognizedGUIDException,
                                          PropertyServerException,
                                          FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    restoreSynonymRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - createAntonymRelationship
```
public Antonym createAntonymRelationship(String userId,
                                         Antonym antonym)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         MetadataServerUncontactableException,
                                         UnexpectedResponseException,
                                         UnrecognizedGUIDException,
                                         PropertyServerException,
                                         FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Create a antonym relationship. A link between glossary terms that have the opposite meaning.
    
    Specified by:
    
    createAntonymRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    antonym - the Antonym relationship
    
    Returns:
    
    the created antonym relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getAntonymRelationship
```
public Antonym getAntonymRelationship(String userId,
                                      String guid)
                               throws InvalidParameterException,
                                      MetadataServerUncontactableException,
                                      UserNotAuthorizedException,
                                      UnexpectedResponseException,
                                      UnrecognizedGUIDException,
                                      PropertyServerException,
                                      FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a antonym relationship. A link between glossary terms that have the opposite meaning.
    
    Specified by:
    
    getAntonymRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - updateAntonymRelationship
```
public Antonym updateAntonymRelationship(String userId,
                                         Antonym antonymRelationship)
                                  throws InvalidParameterException,
                                         MetadataServerUncontactableException,
                                         UserNotAuthorizedException,
                                         UnexpectedResponseException,
                                         UnrecognizedGUIDException,
                                         PropertyServerException,
                                         FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Update a Antonym relationship which is a link between glossary terms that have the opposite meaning
    
    Specified by:
    
    updateAntonymRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    antonymRelationship - the Antonym relationship
    
    Returns:
    
    Antonym updated antonym Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - replaceAntonymRelationship
```
public Antonym replaceAntonymRelationship(String userId,
                                          Antonym antonymRelationship)
                                   throws InvalidParameterException,
                                          MetadataServerUncontactableException,
                                          UserNotAuthorizedException,
                                          UnexpectedResponseException,
                                          UnrecognizedGUIDException,
                                          PropertyServerException,
                                          FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace an Antonym relationship which is a link between glossary terms that have the opposite meaning
    
    Specified by:
    
    replaceAntonymRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    antonymRelationship - the antonym relationship
    
    Returns:
    
    Antonym replaced antonym Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deleteAntonymRelationship
```
public Antonym deleteAntonymRelationship(String userId,
                                         String guid)
                                  throws InvalidParameterException,
                                         MetadataServerUncontactableException,
                                         UserNotAuthorizedException,
                                         UnrecognizedGUIDException,
                                         FunctionNotSupportedException,
                                         RelationshipNotDeletedException,
                                         UnexpectedResponseException,
                                         PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    deleteAntonymRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    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.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception Client library Exceptions
  - purgeAntonymRelationship
```
public void purgeAntonymRelationship(String userId,
                                     String guid)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     UnrecognizedGUIDException,
                                     MetadataServerUncontactableException,
                                     UnexpectedResponseException,
                                     RelationshipNotPurgedException,
                                     PropertyServerException,
                                     FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    purgeAntonymRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - restoreAntonymRelationship
```
public Antonym restoreAntonymRelationship(String userId,
                                          String guid)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          MetadataServerUncontactableException,
                                          UnexpectedResponseException,
                                          UnrecognizedGUIDException,
                                          PropertyServerException,
                                          FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    restoreAntonymRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - createTranslationRelationship
```
public Translation createTranslationRelationship(String userId,
                                                 Translation translation)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 MetadataServerUncontactableException,
                                                 UnexpectedResponseException,
                                                 UnrecognizedGUIDException,
                                                 PropertyServerException,
                                                 FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Create a Translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
    
    Specified by:
    
    createTranslationRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    translation - the Translation relationship
    
    Returns:
    
    the created translation relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getTranslationRelationship
```
public Translation getTranslationRelationship(String userId,
                                              String guid)
                                       throws InvalidParameterException,
                                              MetadataServerUncontactableException,
                                              UserNotAuthorizedException,
                                              UnexpectedResponseException,
                                              UnrecognizedGUIDException,
                                              PropertyServerException,
                                              FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
    
    Specified by:
    
    getTranslationRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - updateTranslationRelationship
```
public Translation updateTranslationRelationship(String userId,
                                                 Translation translationRelationship)
                                          throws InvalidParameterException,
                                                 MetadataServerUncontactableException,
                                                 UserNotAuthorizedException,
                                                 UnexpectedResponseException,
                                                 UnrecognizedGUIDException,
                                                 PropertyServerException,
                                                 FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Update a Translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
    
    Specified by:
    
    updateTranslationRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    translationRelationship - the Translation relationship
    
    Returns:
    
    Translation updated translation Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception Client library Exceptions
    
    FunctionNotSupportedException - function not supported
  - replaceTranslationRelationship
```
public Translation replaceTranslationRelationship(String userId,
                                                  Translation translationRelationship)
                                           throws InvalidParameterException,
                                                  MetadataServerUncontactableException,
                                                  UserNotAuthorizedException,
                                                  UnexpectedResponseException,
                                                  UnrecognizedGUIDException,
                                                  PropertyServerException,
                                                  FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace an Translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
    
    Specified by:
    
    replaceTranslationRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    translationRelationship - the translation relationship
    
    Returns:
    
    Translation replaced translation Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deleteTranslationRelationship
```
public Translation deleteTranslationRelationship(String userId,
                                                 String guid)
                                          throws InvalidParameterException,
                                                 MetadataServerUncontactableException,
                                                 UserNotAuthorizedException,
                                                 UnrecognizedGUIDException,
                                                 FunctionNotSupportedException,
                                                 RelationshipNotDeletedException,
                                                 UnexpectedResponseException,
                                                 PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    deleteTranslationRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    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.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception
  - purgeTranslationRelationship
```
public void purgeTranslationRelationship(String userId,
                                         String guid)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         RelationshipNotPurgedException,
                                         UnrecognizedGUIDException,
                                         MetadataServerUncontactableException,
                                         UnexpectedResponseException,
                                         PropertyServerException,
                                         FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    purgeTranslationRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - restoreTranslationRelationship
```
public Translation restoreTranslationRelationship(String userId,
                                                  String guid)
                                           throws InvalidParameterException,
                                                  UserNotAuthorizedException,
                                                  MetadataServerUncontactableException,
                                                  UnexpectedResponseException,
                                                  UnrecognizedGUIDException,
                                                  PropertyServerException,
                                                  FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    restoreTranslationRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - createUsedInContextRelationship
```
public UsedInContext createUsedInContextRelationship(String userId,
                                                     UsedInContext usedInContext)
                                              throws InvalidParameterException,
                                                     UserNotAuthorizedException,
                                                     MetadataServerUncontactableException,
                                                     UnexpectedResponseException,
                                                     UnrecognizedGUIDException,
                                                     PropertyServerException,
                                                     FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Create a UsedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
    
    Specified by:
    
    createUsedInContextRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    usedInContext - the UsedInContext relationship
    
    Returns:
    
    the created usedInContext relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getUsedInContextRelationship
```
public UsedInContext getUsedInContextRelationship(String userId,
                                                  String guid)
                                           throws InvalidParameterException,
                                                  MetadataServerUncontactableException,
                                                  UserNotAuthorizedException,
                                                  UnexpectedResponseException,
                                                  UnrecognizedGUIDException,
                                                  PropertyServerException,
                                                  FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a usedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
    
    Specified by:
    
    getUsedInContextRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - updateUsedInContextRelationship
```
public UsedInContext updateUsedInContextRelationship(String userId,
                                                     UsedInContext usedInContextRelationship)
                                              throws InvalidParameterException,
                                                     MetadataServerUncontactableException,
                                                     UserNotAuthorizedException,
                                                     UnexpectedResponseException,
                                                     UnrecognizedGUIDException,
                                                     PropertyServerException,
                                                     FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Update a UsedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
    
    Specified by:
    
    updateUsedInContextRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    usedInContextRelationship - the UsedInContext relationship
    
    Returns:
    
    UsedInContext updated usedInContext Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - replaceUsedInContextRelationship
```
public UsedInContext replaceUsedInContextRelationship(String userId,
                                                      UsedInContext usedInContextRelationship)
                                               throws InvalidParameterException,
                                                      MetadataServerUncontactableException,
                                                      UserNotAuthorizedException,
                                                      UnexpectedResponseException,
                                                      UnrecognizedGUIDException,
                                                      PropertyServerException,
                                                      FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace an UsedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
    
    Specified by:
    
    replaceUsedInContextRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    usedInContextRelationship - the usedInContext relationship
    
    Returns:
    
    UsedInContext replaced usedInContext Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deleteUsedInContextRelationship
```
public UsedInContext deleteUsedInContextRelationship(String userId,
                                                     String guid)
                                              throws InvalidParameterException,
                                                     MetadataServerUncontactableException,
                                                     UserNotAuthorizedException,
                                                     UnrecognizedGUIDException,
                                                     FunctionNotSupportedException,
                                                     RelationshipNotDeletedException,
                                                     UnexpectedResponseException,
                                                     PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    deleteUsedInContextRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    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.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception Client library Exceptions
  - purgeUsedInContextRelationship
```
public void purgeUsedInContextRelationship(String userId,
                                           String guid)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           RelationshipNotPurgedException,
                                           UnrecognizedGUIDException,
                                           MetadataServerUncontactableException,
                                           UnexpectedResponseException,
                                           PropertyServerException,
                                           FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    purgeUsedInContextRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - restoreUsedInContextRelationship
```
public UsedInContext restoreUsedInContextRelationship(String userId,
                                                      String guid)
                                               throws InvalidParameterException,
                                                      UserNotAuthorizedException,
                                                      MetadataServerUncontactableException,
                                                      UnexpectedResponseException,
                                                      UnrecognizedGUIDException,
                                                      PropertyServerException,
                                                      FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Restore a Used in context relationship Restore allows the deleted Used 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.
    
    Specified by:
    
    restoreUsedInContextRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported
  - createPreferredTermRelationship
```
public PreferredTerm createPreferredTermRelationship(String userId,
                                                     PreferredTerm preferredTerm)
                                              throws InvalidParameterException,
                                                     UserNotAuthorizedException,
                                                     MetadataServerUncontactableException,
                                                     UnexpectedResponseException,
                                                     UnrecognizedGUIDException,
                                                     PropertyServerException,
                                                     FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Create a PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
    
    Specified by:
    
    createPreferredTermRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    preferredTerm - the PreferredTerm relationship
    
    Returns:
    
    the created preferredTerm relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getPreferredTermRelationship
```
public PreferredTerm getPreferredTermRelationship(String userId,
                                                  String guid)
                                           throws InvalidParameterException,
                                                  MetadataServerUncontactableException,
                                                  UserNotAuthorizedException,
                                                  UnexpectedResponseException,
                                                  UnrecognizedGUIDException,
                                                  PropertyServerException,
                                                  FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a preferredTerm relationship, which is link to an alternative term that the organization prefer is used.
    
    Specified by:
    
    getPreferredTermRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - updatePreferredTermRelationship
```
public PreferredTerm updatePreferredTermRelationship(String userId,
                                                     PreferredTerm preferredTermRelationship)
                                              throws InvalidParameterException,
                                                     MetadataServerUncontactableException,
                                                     UserNotAuthorizedException,
                                                     UnexpectedResponseException,
                                                     UnrecognizedGUIDException,
                                                     PropertyServerException,
                                                     FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Update a PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
    
    Specified by:
    
    updatePreferredTermRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    preferredTermRelationship - the PreferredTerm relationship
    
    Returns:
    
    PreferredTerm updated preferredTerm Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - replacePreferredTermRelationship
```
public PreferredTerm replacePreferredTermRelationship(String userId,
                                                      PreferredTerm preferredTermRelationship)
                                               throws InvalidParameterException,
                                                      MetadataServerUncontactableException,
                                                      UserNotAuthorizedException,
                                                      UnexpectedResponseException,
                                                      UnrecognizedGUIDException,
                                                      PropertyServerException,
                                                      FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace an PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
    
    Specified by:
    
    replacePreferredTermRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    preferredTermRelationship - the preferredTerm relationship
    
    Returns:
    
    PreferredTerm replaced preferredTerm Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deletePreferredTermRelationship
```
public PreferredTerm deletePreferredTermRelationship(String userId,
                                                     String guid)
                                              throws InvalidParameterException,
                                                     MetadataServerUncontactableException,
                                                     UserNotAuthorizedException,
                                                     UnrecognizedGUIDException,
                                                     FunctionNotSupportedException,
                                                     RelationshipNotDeletedException,
                                                     UnexpectedResponseException,
                                                     PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    deletePreferredTermRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    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.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception
  - purgePreferredTermRelationship
```
public void purgePreferredTermRelationship(String userId,
                                           String guid)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           RelationshipNotPurgedException,
                                           UnrecognizedGUIDException,
                                           MetadataServerUncontactableException,
                                           UnexpectedResponseException,
                                           PropertyServerException,
                                           FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    purgePreferredTermRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - restorePreferredTermRelationship
```
public PreferredTerm restorePreferredTermRelationship(String userId,
                                                      String guid)
                                               throws InvalidParameterException,
                                                      UserNotAuthorizedException,
                                                      MetadataServerUncontactableException,
                                                      UnexpectedResponseException,
                                                      UnrecognizedGUIDException,
                                                      PropertyServerException,
                                                      FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Restore a preferred term relationship Restore allows the deleted preferred 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.
    
    Specified by:
    
    restorePreferredTermRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - createValidValueRelationship
```
public ValidValue createValidValueRelationship(String userId,
                                               ValidValue validValue)
                                        throws InvalidParameterException,
                                               UserNotAuthorizedException,
                                               MetadataServerUncontactableException,
                                               UnexpectedResponseException,
                                               UnrecognizedGUIDException,
                                               PropertyServerException,
                                               FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Create a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    
    Specified by:
    
    createValidValueRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    validValue - the ValidValue relationship
    
    Returns:
    
    the created validValue relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getValidValueRelationship
```
public ValidValue getValidValueRelationship(String userId,
                                            String guid)
                                     throws InvalidParameterException,
                                            MetadataServerUncontactableException,
                                            UserNotAuthorizedException,
                                            UnexpectedResponseException,
                                            UnrecognizedGUIDException,
                                            PropertyServerException,
                                            FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a validValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    
    Specified by:
    
    getValidValueRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - updateValidValueRelationship
```
public ValidValue updateValidValueRelationship(String userId,
                                               ValidValue validValueRelationship)
                                        throws InvalidParameterException,
                                               MetadataServerUncontactableException,
                                               UserNotAuthorizedException,
                                               UnexpectedResponseException,
                                               UnrecognizedGUIDException,
                                               PropertyServerException,
                                               FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Update a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    
    Specified by:
    
    updateValidValueRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    validValueRelationship - the ValidValue relationship
    
    Returns:
    
    ValidValue updated validValue Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - replaceValidValueRelationship
```
public ValidValue replaceValidValueRelationship(String userId,
                                                ValidValue validValueRelationship)
                                         throws InvalidParameterException,
                                                MetadataServerUncontactableException,
                                                UserNotAuthorizedException,
                                                UnexpectedResponseException,
                                                UnrecognizedGUIDException,
                                                PropertyServerException,
                                                FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace an ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    
    Specified by:
    
    replaceValidValueRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    validValueRelationship - the validValue relationship
    
    Returns:
    
    ValidValue replaced validValue Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deleteValidValueRelationship
```
public ValidValue deleteValidValueRelationship(String userId,
                                               String guid)
                                        throws InvalidParameterException,
                                               MetadataServerUncontactableException,
                                               UserNotAuthorizedException,
                                               UnrecognizedGUIDException,
                                               FunctionNotSupportedException,
                                               RelationshipNotDeletedException,
                                               UnexpectedResponseException,
                                               PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    deleteValidValueRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    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.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception Client library Exceptions
  - purgeValidValueRelationship
```
public void purgeValidValueRelationship(String userId,
                                        String guid)
                                 throws InvalidParameterException,
                                        UserNotAuthorizedException,
                                        RelationshipNotPurgedException,
                                        UnrecognizedGUIDException,
                                        MetadataServerUncontactableException,
                                        UnexpectedResponseException,
                                        PropertyServerException,
                                        FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    purgeValidValueRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - restoreValidValueRelationship
```
public ValidValue restoreValidValueRelationship(String userId,
                                                String guid)
                                         throws InvalidParameterException,
                                                UserNotAuthorizedException,
                                                MetadataServerUncontactableException,
                                                UnexpectedResponseException,
                                                UnrecognizedGUIDException,
                                                PropertyServerException,
                                                FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Restore a valid value relationship Restore allows the deleted valid 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.
    
    Specified by:
    
    restoreValidValueRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - createReplacementTermRelationship
```
public ReplacementTerm createReplacementTermRelationship(String userId,
                                                         ReplacementTerm replacementTerm)
                                                  throws InvalidParameterException,
                                                         UserNotAuthorizedException,
                                                         MetadataServerUncontactableException,
                                                         UnexpectedResponseException,
                                                         UnrecognizedGUIDException,
                                                         PropertyServerException,
                                                         FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Create a ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
    
    Specified by:
    
    createReplacementTermRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    replacementTerm - the ReplacementTerm relationship
    
    Returns:
    
    the created replacementTerm relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getReplacementTermRelationship
```
public ReplacementTerm getReplacementTermRelationship(String userId,
                                                      String guid)
                                               throws InvalidParameterException,
                                                      MetadataServerUncontactableException,
                                                      UserNotAuthorizedException,
                                                      UnexpectedResponseException,
                                                      UnrecognizedGUIDException,
                                                      PropertyServerException,
                                                      FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a replacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
    
    Specified by:
    
    getReplacementTermRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - updateReplacementTermRelationship
```
public ReplacementTerm updateReplacementTermRelationship(String userId,
                                                         ReplacementTerm replacementTermRelationship)
                                                  throws InvalidParameterException,
                                                         MetadataServerUncontactableException,
                                                         UserNotAuthorizedException,
                                                         UnexpectedResponseException,
                                                         UnrecognizedGUIDException,
                                                         PropertyServerException,
                                                         FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Update a ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
    
    Specified by:
    
    updateReplacementTermRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    replacementTermRelationship - the ReplacementTerm relationship
    
    Returns:
    
    ReplacementTerm updated replacementTerm Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - replaceReplacementTermRelationship
```
public ReplacementTerm replaceReplacementTermRelationship(String userId,
                                                          ReplacementTerm replacementTermRelationship)
                                                   throws InvalidParameterException,
                                                          MetadataServerUncontactableException,
                                                          UserNotAuthorizedException,
                                                          UnexpectedResponseException,
                                                          UnrecognizedGUIDException,
                                                          PropertyServerException,
                                                          FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace an ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
    
    Specified by:
    
    replaceReplacementTermRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    replacementTermRelationship - the replacementTerm relationship
    
    Returns:
    
    ReplacementTerm replaced replacementTerm Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deleteReplacementTermRelationship
```
public ReplacementTerm deleteReplacementTermRelationship(String userId,
                                                         String guid)
                                                  throws InvalidParameterException,
                                                         MetadataServerUncontactableException,
                                                         UserNotAuthorizedException,
                                                         UnrecognizedGUIDException,
                                                         FunctionNotSupportedException,
                                                         RelationshipNotDeletedException,
                                                         UnexpectedResponseException,
                                                         PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    deleteReplacementTermRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    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.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception Client library Exceptions
  - purgeReplacementTermRelationship
```
public void purgeReplacementTermRelationship(String userId,
                                             String guid)
                                      throws InvalidParameterException,
                                             UserNotAuthorizedException,
                                             RelationshipNotPurgedException,
                                             UnrecognizedGUIDException,
                                             MetadataServerUncontactableException,
                                             UnexpectedResponseException,
                                             PropertyServerException,
                                             FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    purgeReplacementTermRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - restoreReplacementTermRelationship
```
public ReplacementTerm restoreReplacementTermRelationship(String userId,
                                                          String guid)
                                                   throws InvalidParameterException,
                                                          UserNotAuthorizedException,
                                                          MetadataServerUncontactableException,
                                                          UnexpectedResponseException,
                                                          UnrecognizedGUIDException,
                                                          PropertyServerException,
                                                          FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    restoreReplacementTermRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - createTermTYPEDBYRelationship
```
public TypedBy createTermTYPEDBYRelationship(String userId,
                                             TypedBy termTYPEDBYRelationship)
                                      throws InvalidParameterException,
                                             UserNotAuthorizedException,
                                             MetadataServerUncontactableException,
                                             UnexpectedResponseException,
                                             UnrecognizedGUIDException,
                                             PropertyServerException,
                                             FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Create a TypedBy relationship, which is defines the relationship between a spine attribute and its type.
    
    Specified by:
    
    createTermTYPEDBYRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    termTYPEDBYRelationship - the TypedBy relationship
    
    Returns:
    
    the created termTYPEDBYRelationship relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getTermTYPEDBYRelationship
```
public TypedBy getTermTYPEDBYRelationship(String userId,
                                          String guid)
                                   throws InvalidParameterException,
                                          MetadataServerUncontactableException,
                                          UserNotAuthorizedException,
                                          UnexpectedResponseException,
                                          UnrecognizedGUIDException,
                                          PropertyServerException,
                                          FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a termTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
    
    Specified by:
    
    getTermTYPEDBYRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to get
    
    Returns:
    
    TypedBy Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - updateTermTYPEDBYRelationship
```
public TypedBy updateTermTYPEDBYRelationship(String userId,
                                             TypedBy termTYPEDBYRelationship)
                                      throws InvalidParameterException,
                                             MetadataServerUncontactableException,
                                             UserNotAuthorizedException,
                                             UnexpectedResponseException,
                                             UnrecognizedGUIDException,
                                             PropertyServerException,
                                             FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Update a TypedBy relationship, which is defines the relationship between a spine attribute and its type.
    
    Specified by:
    
    updateTermTYPEDBYRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    termTYPEDBYRelationship - the TypedBy relationship
    
    Returns:
    
    TypedBy updated termTYPEDBYRelationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - replaceTermTYPEDBYRelationship
```
public TypedBy replaceTermTYPEDBYRelationship(String userId,
                                              TypedBy termTYPEDBYRelationship)
                                       throws InvalidParameterException,
                                              MetadataServerUncontactableException,
                                              UserNotAuthorizedException,
                                              UnexpectedResponseException,
                                              UnrecognizedGUIDException,
                                              PropertyServerException,
                                              FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace an TypedBy relationship, which is defines the relationship between a spine attribute and its type.
    
    Specified by:
    
    replaceTermTYPEDBYRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    termTYPEDBYRelationship - the termTYPEDBYRelationship relationship
    
    Returns:
    
    TypedBy replaced termTYPEDBYRelationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deleteTermTYPEDBYRelationship
```
public TypedBy deleteTermTYPEDBYRelationship(String userId,
                                             String guid)
                                      throws InvalidParameterException,
                                             MetadataServerUncontactableException,
                                             UserNotAuthorizedException,
                                             UnrecognizedGUIDException,
                                             FunctionNotSupportedException,
                                             RelationshipNotDeletedException,
                                             UnexpectedResponseException,
                                             PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    deleteTermTYPEDBYRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete
    
    Returns:
    
    deleted TypedBy Exceptions returned by the server
    
    Throws:
    
    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.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception Client library Exceptions
  - purgeTermTYPEDBYRelationship
```
public void purgeTermTYPEDBYRelationship(String userId,
                                         String guid)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         RelationshipNotPurgedException,
                                         UnrecognizedGUIDException,
                                         MetadataServerUncontactableException,
                                         UnexpectedResponseException,
                                         PropertyServerException,
                                         FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    purgeTermTYPEDBYRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TypedBy relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - restoreTypedByRelationship
```
public TypedBy restoreTypedByRelationship(String userId,
                                          String guid)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          MetadataServerUncontactableException,
                                          UnexpectedResponseException,
                                          UnrecognizedGUIDException,
                                          PropertyServerException,
                                          FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    restoreTypedByRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - createIsaRelationship
```
public Isa createIsaRelationship(String userId,
                                 Isa isa)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 MetadataServerUncontactableException,
                                 UnexpectedResponseException,
                                 UnrecognizedGUIDException,
                                 PropertyServerException,
                                 FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Create a Isa relationship, which is link between a more general glossary term and a more specific definition.
    
    Specified by:
    
    createIsaRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    isa - the Isa relationship
    
    Returns:
    
    the created isa relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getIsaRelationship
```
public Isa getIsaRelationship(String userId,
                              String guid)
                       throws InvalidParameterException,
                              MetadataServerUncontactableException,
                              UserNotAuthorizedException,
                              UnexpectedResponseException,
                              UnrecognizedGUIDException,
                              PropertyServerException,
                              FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a isa relationship, which is link between a more general glossary term and a more specific definition.
    
    Specified by:
    
    getIsaRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - updateIsaRelationship
```
public Isa updateIsaRelationship(String userId,
                                 Isa isaRelationship)
                          throws InvalidParameterException,
                                 MetadataServerUncontactableException,
                                 UserNotAuthorizedException,
                                 UnexpectedResponseException,
                                 UnrecognizedGUIDException,
                                 PropertyServerException,
                                 FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Update a Isa relationship, which is link between a more general glossary term and a more specific definition.
    
    Specified by:
    
    updateIsaRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    isaRelationship - the Isa relationship
    
    Returns:
    
    Isa updated isa Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - replaceIsaRelationship
```
public Isa replaceIsaRelationship(String userId,
                                  Isa isaRelationship)
                           throws InvalidParameterException,
                                  MetadataServerUncontactableException,
                                  UserNotAuthorizedException,
                                  UnexpectedResponseException,
                                  UnrecognizedGUIDException,
                                  PropertyServerException,
                                  FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace an Isa relationship, which is link between a more general glossary term and a more specific definition.
    
    Specified by:
    
    replaceIsaRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    isaRelationship - the isa relationship
    
    Returns:
    
    Isa replaced isa Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deleteIsaRelationship
```
public Isa deleteIsaRelationship(String userId,
                                 String guid)
                          throws InvalidParameterException,
                                 MetadataServerUncontactableException,
                                 UserNotAuthorizedException,
                                 UnrecognizedGUIDException,
                                 FunctionNotSupportedException,
                                 RelationshipNotDeletedException,
                                 UnexpectedResponseException,
                                 PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    deleteIsaRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    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.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception Client library Exceptions
  - purgeIsaRelationship
```
public void purgeIsaRelationship(String userId,
                                 String guid)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 RelationshipNotPurgedException,
                                 UnrecognizedGUIDException,
                                 MetadataServerUncontactableException,
                                 UnexpectedResponseException,
                                 PropertyServerException,
                                 FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    purgeIsaRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - restoreIsaRelationship
```
public Isa restoreIsaRelationship(String userId,
                                  String guid)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  MetadataServerUncontactableException,
                                  UnexpectedResponseException,
                                  UnrecognizedGUIDException,
                                  PropertyServerException,
                                  FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    restoreIsaRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - createTermISATypeOFRelationship
```
public IsaTypeOf createTermISATypeOFRelationship(String userId,
                                                 IsaTypeOf isaTypeOf)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 MetadataServerUncontactableException,
                                                 UnexpectedResponseException,
                                                 UnrecognizedGUIDException,
                                                 PropertyServerException,
                                                 FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Create a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
    
    Specified by:
    
    createTermISATypeOFRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    isaTypeOf - the IsaTypeOf relationship
    
    Returns:
    
    the created IsaTypeOf relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getTermISATypeOFRelationship
```
public IsaTypeOf getTermISATypeOFRelationship(String userId,
                                              String guid)
                                       throws InvalidParameterException,
                                              MetadataServerUncontactableException,
                                              UserNotAuthorizedException,
                                              UnexpectedResponseException,
                                              UnrecognizedGUIDException,
                                              PropertyServerException,
                                              FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
    
    Specified by:
    
    getTermISATypeOFRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to get
    
    Returns:
    
    IsaTypeOf Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - updateTermISATypeOFRelationship
```
public IsaTypeOf updateTermISATypeOFRelationship(String userId,
                                                 IsaTypeOf isATypeOf)
                                          throws InvalidParameterException,
                                                 MetadataServerUncontactableException,
                                                 UserNotAuthorizedException,
                                                 UnexpectedResponseException,
                                                 UnrecognizedGUIDException,
                                                 PropertyServerException,
                                                 FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Update a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
    
    Specified by:
    
    updateTermISATypeOFRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    isATypeOf - the IsaTypeOf relationship
    
    Returns:
    
    IsaTypeOf updated IsaTypeOf Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - replaceTermISATypeOFRelationship
```
public IsaTypeOf replaceTermISATypeOFRelationship(String userId,
                                                  IsaTypeOf isATypeOf)
                                           throws InvalidParameterException,
                                                  MetadataServerUncontactableException,
                                                  UserNotAuthorizedException,
                                                  UnexpectedResponseException,
                                                  UnrecognizedGUIDException,
                                                  PropertyServerException,
                                                  FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace an isATypeOf relationship, which is defines an inheritance relationship between two spine objects.
    
    Specified by:
    
    replaceTermISATypeOFRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    isATypeOf - the isATypeOf relationship
    
    Returns:
    
    isATypeOf replaced isATypeOf Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deleteTermISATypeOFRelationship
```
public IsaTypeOf deleteTermISATypeOFRelationship(String userId,
                                                 String guid)
                                          throws InvalidParameterException,
                                                 MetadataServerUncontactableException,
                                                 UserNotAuthorizedException,
                                                 UnrecognizedGUIDException,
                                                 FunctionNotSupportedException,
                                                 RelationshipNotDeletedException,
                                                 UnexpectedResponseException,
                                                 PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    Delete a IsaTypeOf 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.
    
    Specified by:
    
    deleteTermISATypeOFRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete
    
    Returns:
    
    deleted IsaTypeOf Exceptions returned by the server
    
    Throws:
    
    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.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception Client library Exceptions
  - purgeTermISATypeOFRelationship
```
public void purgeTermISATypeOFRelationship(String userId,
                                           String guid)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           RelationshipNotPurgedException,
                                           UnrecognizedGUIDException,
                                           MetadataServerUncontactableException,
                                           UnexpectedResponseException,
                                           PropertyServerException,
                                           FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Purge a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects. A purge means that the relationship will not exist after the operation.
    
    Specified by:
    
    purgeTermISATypeOFRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the IsaTypeOf relationship to delete when not successful the following Exception responses can occur Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - restoreIsaTypeOfRelationship
```
public IsaTypeOf restoreIsaTypeOfRelationship(String userId,
                                              String guid)
                                       throws InvalidParameterException,
                                              UserNotAuthorizedException,
                                              MetadataServerUncontactableException,
                                              UnexpectedResponseException,
                                              UnrecognizedGUIDException,
                                              PropertyServerException,
                                              FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    restoreIsaTypeOfRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - createTermCategorizationRelationship
```
public Categorization createTermCategorizationRelationship(String userId,
                                                           Categorization categorization)
                                                    throws InvalidParameterException,
                                                           UserNotAuthorizedException,
                                                           MetadataServerUncontactableException,
                                                           UnexpectedResponseException,
                                                           UnrecognizedGUIDException,
                                                           PropertyServerException,
                                                           FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    createTermCategorizationRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    categorization - the term categorization relationship
    
    Returns:
    
    the created term categorization relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getTermCategorizationRelationship
```
public Categorization getTermCategorizationRelationship(String userId,
                                                        String guid)
                                                 throws InvalidParameterException,
                                                        MetadataServerUncontactableException,
                                                        UserNotAuthorizedException,
                                                        UnexpectedResponseException,
                                                        UnrecognizedGUIDException,
                                                        PropertyServerException,
                                                        FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a Term Categorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.
    
    Specified by:
    
    getTermCategorizationRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - updateTermCategorizationRelationship
```
public Categorization updateTermCategorizationRelationship(String userId,
                                                           Categorization termCategorizationRelationship)
                                                    throws InvalidParameterException,
                                                           UserNotAuthorizedException,
                                                           MetadataServerUncontactableException,
                                                           UnexpectedResponseException,
                                                           UnrecognizedGUIDException,
                                                           PropertyServerException,
                                                           FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Update a Term Categorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.
    
    Specified by:
    
    updateTermCategorizationRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    termCategorizationRelationship - the term categorization relationship
    
    Returns:
    
    the updated term categorization relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - replaceTermCategorizationRelationship
```
public Categorization replaceTermCategorizationRelationship(String userId,
                                                            Categorization termCategorizationRelationship)
                                                     throws InvalidParameterException,
                                                            UserNotAuthorizedException,
                                                            MetadataServerUncontactableException,
                                                            UnexpectedResponseException,
                                                            UnrecognizedGUIDException,
                                                            PropertyServerException,
                                                            FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace a Term HASA Relationship.
    
    Specified by:
    
    replaceTermCategorizationRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    termCategorizationRelationship - the term categorization relationship
    
    Returns:
    
    the replaced term categorization relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deleteTermCategorizationRelationship
```
public Categorization deleteTermCategorizationRelationship(String userId,
                                                           String guid)
                                                    throws InvalidParameterException,
                                                           MetadataServerUncontactableException,
                                                           UserNotAuthorizedException,
                                                           UnrecognizedGUIDException,
                                                           FunctionNotSupportedException,
                                                           RelationshipNotDeletedException,
                                                           UnexpectedResponseException,
                                                           PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    deleteTermCategorizationRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    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.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception Client library Exceptions
  - purgeTermCategorizationRelationship
```
public void purgeTermCategorizationRelationship(String userId,
                                                String guid)
                                         throws InvalidParameterException,
                                                UserNotAuthorizedException,
                                                RelationshipNotPurgedException,
                                                UnrecognizedGUIDException,
                                                MetadataServerUncontactableException,
                                                UnexpectedResponseException,
                                                PropertyServerException,
                                                FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    purgeTermCategorizationRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - restoreTermCategorizationRelationship
```
public Categorization restoreTermCategorizationRelationship(String userId,
                                                            String guid)
                                                     throws InvalidParameterException,
                                                            UserNotAuthorizedException,
                                                            MetadataServerUncontactableException,
                                                            UnexpectedResponseException,
                                                            UnrecognizedGUIDException,
                                                            PropertyServerException,
                                                            FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    restoreTermCategorizationRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - createTermAnchorRelationship
```
public TermAnchor createTermAnchorRelationship(String userId,
                                               TermAnchor termAnchor)
                                        throws InvalidParameterException,
                                               UserNotAuthorizedException,
                                               MetadataServerUncontactableException,
                                               UnexpectedResponseException,
                                               UnrecognizedGUIDException,
                                               PropertyServerException,
                                               FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    createTermAnchorRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    termAnchor - the TermAnchor relationship
    
    Returns:
    
    the created TermAnchor relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getTermAnchorRelationship
```
public TermAnchor getTermAnchorRelationship(String userId,
                                            String guid)
                                     throws InvalidParameterException,
                                            MetadataServerUncontactableException,
                                            UserNotAuthorizedException,
                                            UnexpectedResponseException,
                                            UnrecognizedGUIDException,
                                            PropertyServerException,
                                            FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a Term Anchor Relationship. A relationship between a Glossary and a Term. This relationship allows terms to be owned by a glossary.
    
    Specified by:
    
    getTermAnchorRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - replaceTermAnchorRelationship
```
public TermAnchor replaceTermAnchorRelationship(String userId,
                                                TermAnchor termCategorizationRelationship)
                                         throws InvalidParameterException,
                                                UserNotAuthorizedException,
                                                MetadataServerUncontactableException,
                                                UnexpectedResponseException,
                                                UnrecognizedGUIDException,
                                                PropertyServerException,
                                                FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace a Term HASA Relationship.
    
    Specified by:
    
    replaceTermAnchorRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    termCategorizationRelationship - the TermAnchor relationship
    
    Returns:
    
    the updated TermAnchor relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deleteTermAnchorRelationship
```
public TermAnchor deleteTermAnchorRelationship(String userId,
                                               String guid)
                                        throws InvalidParameterException,
                                               MetadataServerUncontactableException,
                                               UserNotAuthorizedException,
                                               UnrecognizedGUIDException,
                                               FunctionNotSupportedException,
                                               RelationshipNotDeletedException,
                                               UnexpectedResponseException,
                                               PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    deleteTermAnchorRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    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.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception Client library Exceptions
  - purgeTermAnchorRelationship
```
public void purgeTermAnchorRelationship(String userId,
                                        String guid)
                                 throws InvalidParameterException,
                                        UserNotAuthorizedException,
                                        RelationshipNotPurgedException,
                                        UnrecognizedGUIDException,
                                        MetadataServerUncontactableException,
                                        UnexpectedResponseException,
                                        PropertyServerException,
                                        FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    purgeTermAnchorRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - restoreTermAnchorRelationship
```
public TermAnchor restoreTermAnchorRelationship(String userId,
                                                String guid)
                                         throws InvalidParameterException,
                                                UserNotAuthorizedException,
                                                MetadataServerUncontactableException,
                                                UnexpectedResponseException,
                                                UnrecognizedGUIDException,
                                                PropertyServerException,
                                                FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    restoreTermAnchorRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - createCategoryAnchorRelationship
```
public CategoryAnchor createCategoryAnchorRelationship(String userId,
                                                       CategoryAnchor categoryAnchor)
                                                throws InvalidParameterException,
                                                       UserNotAuthorizedException,
                                                       MetadataServerUncontactableException,
                                                       UnexpectedResponseException,
                                                       UnrecognizedGUIDException,
                                                       PropertyServerException,
                                                       FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    createCategoryAnchorRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    categoryAnchor - the category anchor relationship
    
    Returns:
    
    the created term categorization relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getCategoryAnchorRelationship
```
public CategoryAnchor getCategoryAnchorRelationship(String userId,
                                                    String guid)
                                             throws InvalidParameterException,
                                                    MetadataServerUncontactableException,
                                                    UserNotAuthorizedException,
                                                    UnexpectedResponseException,
                                                    UnrecognizedGUIDException,
                                                    PropertyServerException,
                                                    FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a Category Anchor Relationship. A relationship between a Glossary and a Category. This relationship allows categoriess to be owned by a glossary.
    
    Specified by:
    
    getCategoryAnchorRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - updateCategoryAnchorRelationship
```
public CategoryAnchor updateCategoryAnchorRelationship(String userId,
                                                       CategoryAnchor termCategorizationRelationship)
                                                throws InvalidParameterException,
                                                       UserNotAuthorizedException,
                                                       MetadataServerUncontactableException,
                                                       UnexpectedResponseException,
                                                       UnrecognizedGUIDException,
                                                       PropertyServerException,
                                                       FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Update a Category Anchor Relationship.
    
    Specified by:
    
    updateCategoryAnchorRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    termCategorizationRelationship - the category anchor relationship
    
    Returns:
    
    the updated category anchor relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - replaceCategoryAnchorRelationship
```
public CategoryAnchor replaceCategoryAnchorRelationship(String userId,
                                                        CategoryAnchor termCategorizationRelationship)
                                                 throws InvalidParameterException,
                                                        UserNotAuthorizedException,
                                                        MetadataServerUncontactableException,
                                                        UnexpectedResponseException,
                                                        UnrecognizedGUIDException,
                                                        PropertyServerException,
                                                        FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace a Category Anchor Relationship.
    
    Specified by:
    
    replaceCategoryAnchorRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    termCategorizationRelationship - the category anchor relationship
    
    Returns:
    
    the replaced category anchor relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deleteCategoryAnchorRelationship
```
public CategoryAnchor deleteCategoryAnchorRelationship(String userId,
                                                       String guid)
                                                throws InvalidParameterException,
                                                       MetadataServerUncontactableException,
                                                       UserNotAuthorizedException,
                                                       UnrecognizedGUIDException,
                                                       FunctionNotSupportedException,
                                                       RelationshipNotDeletedException,
                                                       UnexpectedResponseException,
                                                       PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    Delete a Category Anchor Relationship. A relationship between a Glossary and a Category. This relationship allows categories 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.
    
    Specified by:
    
    deleteCategoryAnchorRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    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.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    FunctionNotSupportedException - Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception Client library Exceptions
  - purgeCategoryAnchorRelationship
```
public void purgeCategoryAnchorRelationship(String userId,
                                            String guid)
                                     throws InvalidParameterException,
                                            UserNotAuthorizedException,
                                            RelationshipNotPurgedException,
                                            UnrecognizedGUIDException,
                                            MetadataServerUncontactableException,
                                            UnexpectedResponseException,
                                            PropertyServerException,
                                            FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    purgeCategoryAnchorRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - restoreCategoryAnchorRelationship
```
public CategoryAnchor restoreCategoryAnchorRelationship(String userId,
                                                        String guid)
                                                 throws InvalidParameterException,
                                                        UserNotAuthorizedException,
                                                        MetadataServerUncontactableException,
                                                        UnexpectedResponseException,
                                                        UnrecognizedGUIDException,
                                                        PropertyServerException,
                                                        FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    restoreCategoryAnchorRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - createProjectScopeRelationship
```
public ProjectScope createProjectScopeRelationship(String userId,
                                                   ProjectScope projectScope)
                                            throws InvalidParameterException,
                                                   UserNotAuthorizedException,
                                                   MetadataServerUncontactableException,
                                                   UnexpectedResponseException,
                                                   UnrecognizedGUIDException,
                                                   PropertyServerException,
                                                   FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Create a ProjectScope relationship. A link between the project content and the project.
    
    Specified by:
    
    createProjectScopeRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    projectScope - the ProjectScope relationship
    
    Returns:
    
    the created ProjectScope relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getProjectScopeRelationship
```
public ProjectScope getProjectScopeRelationship(String userId,
                                                String guid)
                                         throws InvalidParameterException,
                                                MetadataServerUncontactableException,
                                                UserNotAuthorizedException,
                                                UnexpectedResponseException,
                                                UnrecognizedGUIDException,
                                                PropertyServerException,
                                                FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a ProjectScope relationship. A link between the project content and the project.
    
    Specified by:
    
    getProjectScopeRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    MetadataServerUncontactableException - not able to communicate with a Metadata respository service.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - updateProjectScopeRelationship
```
public ProjectScope updateProjectScopeRelationship(String userId,
                                                   ProjectScope projectScopeRelationship)
                                            throws InvalidParameterException,
                                                   MetadataServerUncontactableException,
                                                   UserNotAuthorizedException,
                                                   UnexpectedResponseException,
                                                   UnrecognizedGUIDException,
                                                   PropertyServerException,
                                                   FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Update a ProjectScope relationship which is a link between the project content and the project.
    
    Specified by:
    
    updateProjectScopeRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    projectScopeRelationship - the ProjectScope relationship
    
    Returns:
    
    updated ProjectScope relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - replaceProjectScopeRelationship
```
public ProjectScope replaceProjectScopeRelationship(String userId,
                                                    ProjectScope projectScopeRelationship)
                                             throws InvalidParameterException,
                                                    MetadataServerUncontactableException,
                                                    UserNotAuthorizedException,
                                                    UnexpectedResponseException,
                                                    UnrecognizedGUIDException,
                                                    PropertyServerException,
                                                    FunctionNotSupportedException,
                                                    PropertyServerException,
                                                    FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Replace a ProjectScope relationship which is a link between the project content and the project.
    
    Specified by:
    
    replaceProjectScopeRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    userId - userId under which the request is performed
    
    projectScopeRelationship - the ProjectScope relationship
    
    Returns:
    
    replaced ProjectScope relationship Exceptions returned by the server
    
    Throws:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - deleteProjectScopeRelationship
```
public ProjectScope deleteProjectScopeRelationship(String userId,
                                                   String guid)
                                            throws InvalidParameterException,
                                                   MetadataServerUncontactableException,
                                                   UnrecognizedGUIDException,
                                                   UserNotAuthorizedException,
                                                   FunctionNotSupportedException,
                                                   RelationshipNotDeletedException,
                                                   UnexpectedResponseException,
                                                   PropertyServerException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    deleteProjectScopeRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    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.
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    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.
    
    RelationshipNotDeletedException - a soft delete was issued but the relationship was not deleted.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception Client library Exceptions
  - purgeProjectScopeRelationship
```
public void purgeProjectScopeRelationship(String userId,
                                          String guid)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          RelationshipNotPurgedException,
                                          UnrecognizedGUIDException,
                                          MetadataServerUncontactableException,
                                          UnexpectedResponseException,
                                          PropertyServerException,
                                          FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    purgeProjectScopeRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    RelationshipNotPurgedException - a hard delete was issued but the relationship was not purged
    
    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.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - restoreProjectScopeRelationship
```
public ProjectScope restoreProjectScopeRelationship(String userId,
                                                    String guid)
                                             throws InvalidParameterException,
                                                    UserNotAuthorizedException,
                                                    MetadataServerUncontactableException,
                                                    UnexpectedResponseException,
                                                    UnrecognizedGUIDException,
                                                    PropertyServerException,
                                                    FunctionNotSupportedException,
                                                    PropertyServerException,
                                                    FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    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.
    
    Specified by:
    
    restoreProjectScopeRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions
  - getSemanticAssignmentRelationship
```
public SemanticAssignment getSemanticAssignmentRelationship(String userId,
                                                            String guid)
                                                     throws InvalidParameterException,
                                                            MetadataServerUncontactableException,
                                                            UserNotAuthorizedException,
                                                            UnexpectedResponseException,
                                                            UnrecognizedGUIDException,
                                                            PropertyServerException,
                                                            FunctionNotSupportedException
```
    Description copied from interface: SubjectAreaRelationship
    
    Get a SemanticAssignment relationship, Links a glossary term to another element such as an asset or schema element to define its meaning.
    
    Specified by:
    
    getSemanticAssignmentRelationship in interface SubjectAreaRelationship
    
    Parameters:
    
    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:
    
    InvalidParameterException - one of the parameters is null or invalid
    
    MetadataServerUncontactableException - Unable to contact the server
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    UnexpectedResponseException - an unexpected response was returned from the server
    
    UnrecognizedGUIDException - the supplied guid was not recognised
    
    PropertyServerException - property server exception
    
    FunctionNotSupportedException - function not supported Client library Exceptions

Class SubjectAreaRelationshipImpl

Field Summary

Fields inherited from class org.odpi.openmetadata.commonservices.ffdc.rest.FFDCRESTClientBase

Constructor Summary

Method Summary

Methods inherited from class org.odpi.openmetadata.accessservices.subjectarea.client.SubjectAreaBaseImpl

Methods inherited from class org.odpi.openmetadata.commonservices.ffdc.rest.FFDCRESTClient

Methods inherited from class org.odpi.openmetadata.commonservices.ffdc.rest.FFDCRESTClientBase

Methods inherited from class java.lang.Object

Constructor Detail

SubjectAreaRelationshipImpl

Method Detail

createTermHASARelationship

getTermHASARelationship

updateTermHASARelationship

replaceTermHASARelationship

deleteTermHASARelationship

purgeTermHASARelationship

restoreTermHASARelationship

createRelatedTerm

getRelatedTerm

updateRelatedTerm

replaceRelatedTerm

restoreRelatedTerm

deleteRelatedTerm

purgeRelatedTerm

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