java.lang.Object
- org.odpi.openmetadata.viewservices.glossaryauthor.handlers.RelationshipHandler

```
public class RelationshipHandler
extends Object
```
The relationship handler is initialised with a SubjectAreaRelationship, that contains the server the call should be sent to. The handler exposes methods for term functionality for the glossary author view

Constructor Summary

Constructors
Constructor Description

RelationshipHandler(SubjectAreaRelationshipClients subjectAreaRelationship)
Constructor for the RelationshipHandler

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`Antonym`	`createAntonymRelationship(String userId, Antonym antonym)`	Create a antonym relationship.
`CategoryHierarchyLink`	`createCategoryHierarchyLink(String userId, CategoryHierarchyLink categoryHierarchyLink)`	Create a CategoryHierarchyLink 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.
`IsATypeOf`	`createIsATypeOf(String userId, IsATypeOf IsATypeOf)`	Create a IsATypeOf relationship, which is defines an inheritance relationship between two spine objects.
`IsATypeOfDeprecated`	`createIsATypeOfDeprecated(String userId, IsATypeOfDeprecated isATypeOf)`	Create a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
`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.
`Categorization`	`createTermCategorizationRelationship(String userId, Categorization termCategorizationRelationship)`	Create a Term Categorization Relationship.
`HasA`	`createTermHasARelationship(String userId, HasA termHasARelationship)`	Create a Term HasA Relationship.
`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.
`void`	`deleteAntonymRelationship(String userId, String guid)`	Delete a antonym relationship.
`void`	`deleteCategoryHierarchyLink(String userId, String guid)`	Delete a CategoryHierarchyLink Relationship.
`void`	`deleteIsaRelationship(String userId, String guid)`	Delete a isa relationship, which is link between a more general glossary term and a more specific definition.
`void`	`deleteIsATypeOf(String userId, String guid)`	Delete a IsATypeOf relationship, which is defines an inheritance relationship between two spine objects.
`void`	`deleteIsATypeOfDeprecated(String userId, String guid)`	Delete a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
`void`	`deletePreferredTermRelationship(String userId, String guid)`	Delete a preferredTerm relationship, which is link to an alternative term that the organization prefer is used.
`void`	`deleteProjectScopeRelationship(String userId, String guid)`	Delete a ProjectScope relationship.
`void`	`deleteRelatedTerm(String userId, String guid)`	Delete a RelatedTerm.
`void`	`deleteReplacementTermRelationship(String userId, String guid)`	Delete a replacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
`void`	`deleteSynonymRelationship(String userId, String guid)`	Delete a synonym relationship.
`void`	`deleteTermCategorizationRelationship(String userId, String guid)`	Delete a Term Categorization Relationship.
`void`	`deleteTermHasARelationship(String userId, String guid)`	Delete a Term HasA Relationship.
`void`	`deleteTermTYPEDBYRelationship(String userId, String guid)`	Delete a termTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
`void`	`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.
`void`	`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.
`void`	`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.
`CategoryHierarchyLink`	`getCategoryHierarchyLink(String userId, String guid)`	Get a CategoryHierarchyLink 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.
`IsATypeOf`	`getIsATypeOf(String userId, String guid)`	Get a IsATypeOf relationship, which is defines an inheritance relationship between two spine objects.
`IsATypeOfDeprecated`	`getIsATypeOfDeprecated(String userId, String guid)`	Get a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
`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.
`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.
`Antonym`	`replaceAntonymRelationship(String userId, String guid, Antonym antonym)`	Replace an Antonym relationship which is a link between glossary terms that have the opposite meaning
`CategoryHierarchyLink`	`replaceCategoryHierarchyLink(String userId, String guid, CategoryHierarchyLink categoryHierarchyLink)`	Replace a CategoryHierarchyLink Relationship.
`IsA`	`replaceIsaRelationship(String userId, String guid, IsA isa)`	Replace an Isa relationship, which is link between a more general glossary term and a more specific definition.
`IsATypeOf`	`replaceIsATypeOf(String userId, String guid, IsATypeOf IsATypeOf)`	Replace anIsATypeOf relationship, which is defines an inheritance relationship between two spine objects.
`IsATypeOfDeprecated`	`replaceIsATypeOfDeprecated(String userId, String guid, IsATypeOfDeprecated isATypeOf)`	Replace an IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
`PreferredTerm`	`replacePreferredTermRelationship(String userId, String guid, PreferredTerm preferredTerm)`	Replace an PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
`ProjectScope`	`replaceProjectScopeRelationship(String userId, String guid, ProjectScope projectScopeRelationship)`	Replace a ProjectScope relationship which is a link between the project content and the project.
`RelatedTerm`	`replaceRelatedTerm(String userId, String guid, RelatedTerm termRelatedTerm)`	Replace an ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
`ReplacementTerm`	`replaceReplacementTermRelationship(String userId, String guid, ReplacementTerm replacementTerm)`	Replace an ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
`Synonym`	`replaceSynonymRelationship(String userId, String guid, Synonym synonym)`	Replace a Synonym relationship, which is a link between glossary terms that have the same meaning
`Categorization`	`replaceTermCategorizationRelationship(String userId, String guid, Categorization termCategorizationRelationship)`	Replace a Term HasA Relationship.
`HasA`	`replaceTermHasARelationship(String userId, String guid, HasA termHasARelationship)`	Replace a Term HasA Relationship.
`TypedBy`	`replaceTermTYPEDBYRelationship(String userId, String guid, TypedBy termTYPEDBYRelationship)`	Replace an TypedBy relationship, which is defines the relationship between a spine attribute and its type.
`Translation`	`replaceTranslationRelationship(String userId, String guid, Translation translation)`	Replace an Translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
`UsedInContext`	`replaceUsedInContextRelationship(String userId, String guid, UsedInContext usedInContext)`	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, String guid, ValidValue validValue)`	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
`CategoryHierarchyLink`	`restoreCategoryHierarchyLink(String userId, String guid)`	Restore a CategoryHierarchyLink Relationship.
`IsA`	`restoreIsaRelationship(String userId, String guid)`	Restore an is a relationship
`IsATypeOf`	`restoreIsATypeOf(String userId, String guid)`	Restore an is a type of relationship
`IsATypeOfDeprecated`	`restoreIsaTypeOfDeprecated(String userId, String guid)`	Deprecated.
`PreferredTerm`	`restorePreferredTermRelationship(String userId, String guid)`	Restore a preferred term relationship
`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
`RelatedTerm`	`restoreRelatedTermRelationship(String userId, String guid)`	Restore a related term relationship
`ReplacementTerm`	`restoreReplacementTermRelationship(String userId, String guid)`	Restore a replacement term relationship
`Synonym`	`restoreSynonymRelationship(String userId, String guid)`	Restore a Synonym relationship
`Categorization`	`restoreTermCategorizationRelationship(String userId, String guid)`	Restore a Term Categorization Relationship.
`HasA`	`restoreTermHasARelationship(String userId, String guid)`	Restore a Term HasA Relationship.
`Translation`	`restoreTranslationRelationship(String userId, String guid)`	Restore a Translation relationship
`TypedBy`	`restoreTypedByRelationship(String userId, String guid)`	Restore a typed by relationship
`UsedInContext`	`restoreUsedInContextRelationship(String userId, String guid)`	Restore a Used in context relationship
`ValidValue`	`restoreValidValueRelationship(String userId, String guid)`	Restore a valid value relationship
`Antonym`	`updateAntonymRelationship(String userId, String guid, Antonym antonym)`	Update a Antonym relationship which is a link between glossary terms that have the opposite meaning
`CategoryHierarchyLink`	`updateCategoryHierarchyLink(String userId, String guid, CategoryHierarchyLink categoryHierarchyLink)`	Update a CategoryHierarchyLink Relationship.
`IsA`	`updateIsaRelationship(String userId, String guid, IsA isa)`	Update a Isa relationship, which is link between a more general glossary term and a more specific definition.
`IsATypeOf`	`updateIsATypeOf(String userId, String guid, IsATypeOf IsATypeOf)`	Update a IsATypeOf relationship, which is defines an inheritance relationship between two spine objects.
`IsATypeOfDeprecated`	`updateIsATypeOfDeprecated(String userId, String guid, IsATypeOfDeprecated isATypeOf)`	Update a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
`PreferredTerm`	`updatePreferredTermRelationship(String userId, String guid, PreferredTerm preferredTerm)`	Update a PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
`ProjectScope`	`updateProjectScopeRelationship(String userId, String guid, ProjectScope projectScopeRelationship)`	Update a ProjectScope relationship which is a link between the project content and the project.
`RelatedTerm`	`updateRelatedTerm(String userId, String guid, RelatedTerm termRelatedTerm)`	Update a RelatedTerm Relationship.
`ReplacementTerm`	`updateReplacementTermRelationship(String userId, String guid, ReplacementTerm replacementTerm)`	Update a ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
`Synonym`	`updateSynonymRelationship(String userId, String guid, Synonym synonym)`	Update a Synonym relationship which is a link between glossary terms that have the same meaning
`Categorization`	`updateTermCategorizationRelationship(String userId, String guid, Categorization termCategorizationRelationship)`	Update a Term Categorization Relationship.
`HasA`	`updateTermHasARelationship(String userId, String guid, HasA termHasARelationship)`	Update a Term HasA Relationship.
`TypedBy`	`updateTermTYPEDBYRelationship(String userId, String guid, TypedBy termTYPEDBYRelationship)`	Update a TypedBy relationship, which is defines the relationship between a spine attribute and its type.
`Translation`	`updateTranslationRelationship(String userId, String guid, Translation translation)`	Update a Translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
`UsedInContext`	`updateUsedInContextRelationship(String userId, String guid, UsedInContext usedInContext)`	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, String guid, ValidValue validValue)`	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 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - RelationshipHandler
```
public RelationshipHandler(SubjectAreaRelationshipClients subjectAreaRelationship)
```
    Constructor for the RelationshipHandler
    
    Parameters:
    
    subjectAreaRelationship - The SubjectAreaDefinition Open Metadata Access Service (OMAS) API for terms. This is the same as the The SubjectAreaDefinition Open Metadata View Service (OMVS) API for terms.
- Method Detail
  - createTermHasARelationship
```
public HasA createTermHasARelationship(String userId,
                                       HasA termHasARelationship)
                                throws InvalidParameterException,
                                       PropertyServerException,
                                       UserNotAuthorizedException
```
    Create a Term HasA Relationship. A relationship between a spine object and a spine attribute. Note that this method does not error if the relationship ends are not spine objects or spine attributes.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    termHasARelationship - the HasA relationship
    
    Returns:
    
    the created term HasA relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getTermHasARelationship
```
public HasA getTermHasARelationship(String userId,
                                    String guid)
                             throws InvalidParameterException,
                                    UserNotAuthorizedException,
                                    PropertyServerException
```
    Get a Term HasA Relationship. A relationship between a spine object and a spine attribute.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Hasa relationship to get
    
    Returns:
    
    Hasa
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - updateTermHasARelationship
```
public HasA updateTermHasARelationship(String userId,
                                       String guid,
                                       HasA termHasARelationship)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException
```
    Update a Term HasA Relationship. A relationship between a spine object and a spine attribute.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the Hasa relationship
    
    termHasARelationship - the HasA relationship
    
    Returns:
    
    the updated term HasA relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property Server Exception
  - replaceTermHasARelationship
```
public HasA replaceTermHasARelationship(String userId,
                                        String guid,
                                        HasA termHasARelationship)
                                 throws InvalidParameterException,
                                        UserNotAuthorizedException,
                                        PropertyServerException
```
    Replace a Term HasA Relationship.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the Hasa relationship
    
    termHasARelationship - the HasA relationship
    
    Returns:
    
    the replaced term HasA relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deleteTermHasARelationship
```
public void deleteTermHasARelationship(String userId,
                                       String guid)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException
```
    Delete a Term HasA Relationship. A relationship between a spine object and a spine attribute. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Hasa relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - restoreTermHasARelationship
```
public HasA restoreTermHasARelationship(String userId,
                                        String guid)
                                 throws InvalidParameterException,
                                        UserNotAuthorizedException,
                                        PropertyServerException
```
    Restore a Term HasA Relationship. A relationship between a spine object and a spine attribute.
    Restore allows the deleted has a relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the has a relationship to delete
    
    Returns:
    
    the restored has a relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - createRelatedTerm
```
public RelatedTerm createRelatedTerm(String userId,
                                     RelatedTerm relatedTermRelationship)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     PropertyServerException
```
    Create a RelatedTerm. A Related Term is a link between two similar Terms.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    relatedTermRelationship - the RelatedTerm relationship
    
    Returns:
    
    the created RelatedTerm relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property Server Exception
  - getRelatedTerm
```
public RelatedTerm getRelatedTerm(String userId,
                                  String guid)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException
```
    Get a RelatedTerm. A Related Term is a link between two similar Terms.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to get
    
    Returns:
    
    RelatedTerm
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - updateRelatedTerm
```
public RelatedTerm updateRelatedTerm(String userId,
                                     String guid,
                                     RelatedTerm termRelatedTerm)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     PropertyServerException
```
    Update a RelatedTerm Relationship.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    termRelatedTerm - the RelatedTerm relationship
    
    guid - guid of the RelatedTerm relationship
    
    Returns:
    
    the updated term RelatedTerm relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - replaceRelatedTerm
```
public RelatedTerm replaceRelatedTerm(String userId,
                                      String guid,
                                      RelatedTerm termRelatedTerm)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      PropertyServerException
```
    Replace an ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the RelatedTerm relationship
    
    termRelatedTerm - the replacement related term relationship
    
    Returns:
    
    ReplacementTerm replaced related Term relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - restoreRelatedTerm
```
public RelatedTerm restoreRelatedTerm(String userId,
                                      String guid)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      PropertyServerException
```
    Restore a Related Term relationship
    Restore allows the deleted Synonym relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the related term relationship to restore
    
    Returns:
    
    the restored related term relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deleteRelatedTerm
```
public void deleteRelatedTerm(String userId,
                              String guid)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              PropertyServerException
```
    Delete a RelatedTerm. A Related Term is a link between two similar Terms. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the RelatedTerm relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - restoreRelatedTermRelationship
```
public RelatedTerm restoreRelatedTermRelationship(String userId,
                                                  String guid)
                                           throws InvalidParameterException,
                                                  UserNotAuthorizedException,
                                                  PropertyServerException
```
    Restore a related term relationship
    Restore allows the deleted related term relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the related term relationship to delete
    
    Returns:
    
    the restored related term relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - createSynonymRelationship
```
public Synonym createSynonymRelationship(String userId,
                                         Synonym synonym)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
```
    Create a synonym relationship. A link between glossary terms that have the same meaning.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    synonym - the Synonym relationship
    
    Returns:
    
    the created Synonym relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getSynonymRelationship
```
public Synonym getSynonymRelationship(String userId,
                                      String guid)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      PropertyServerException
```
    Get a synonym relationship. A link between glossary terms that have the same meaning.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Synonym relationship to get
    
    Returns:
    
    Synonym
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - updateSynonymRelationship
```
public Synonym updateSynonymRelationship(String userId,
                                         String guid,
                                         Synonym synonym)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
```
    Update a Synonym relationship which is a link between glossary terms that have the same meaning
    
    Parameters:
    
    userId - userId under which the request is performed
    
    synonym - the Synonym relationship
    
    guid - guid of the Synonym relationship
    
    Returns:
    
    updated Synonym relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - replaceSynonymRelationship
```
public Synonym replaceSynonymRelationship(String userId,
                                          String guid,
                                          Synonym synonym)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          PropertyServerException
```
    Replace a Synonym relationship, which is a link between glossary terms that have the same meaning
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the Synonym relationship
    
    synonym - the Synonym relationship
    
    Returns:
    
    replaced synonym relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deleteSynonymRelationship
```
public void deleteSynonymRelationship(String userId,
                                      String guid)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      PropertyServerException
```
    Delete a synonym relationship. A link between glossary terms that have the same meaning. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the synonym relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - restoreSynonymRelationship
```
public Synonym restoreSynonymRelationship(String userId,
                                          String guid)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          PropertyServerException
```
    Restore a Synonym relationship
    Restore allows the deleted Synonym relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Synonym relationship to delete
    
    Returns:
    
    the restored Synonym relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - createAntonymRelationship
```
public Antonym createAntonymRelationship(String userId,
                                         Antonym antonym)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
```
    Create a antonym relationship. A link between glossary terms that have the opposite meaning.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    antonym - the Antonym relationship
    
    Returns:
    
    the created antonym relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getAntonymRelationship
```
public Antonym getAntonymRelationship(String userId,
                                      String guid)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      PropertyServerException
```
    Get a antonym relationship. A link between glossary terms that have the opposite meaning.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Anonym relationship to get
    
    Returns:
    
    Antonym relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - updateAntonymRelationship
```
public Antonym updateAntonymRelationship(String userId,
                                         String guid,
                                         Antonym antonym)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
```
    Update a Antonym relationship which is a link between glossary terms that have the opposite meaning
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the Anonym relationship
    
    antonym - the Antonym relationship
    
    Returns:
    
    Antonym updated antonym
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - replaceAntonymRelationship
```
public Antonym replaceAntonymRelationship(String userId,
                                          String guid,
                                          Antonym antonym)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          PropertyServerException
```
    Replace an Antonym relationship which is a link between glossary terms that have the opposite meaning
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the Anonym relationship
    
    antonym - the antonym relationship
    
    Returns:
    
    Antonym replaced antonym
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deleteAntonymRelationship
```
public void deleteAntonymRelationship(String userId,
                                      String guid)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      PropertyServerException
```
    Delete a antonym relationship. A link between glossary terms that have the opposite meaning. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Antonym relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - restoreAntonymRelationship
```
public Antonym restoreAntonymRelationship(String userId,
                                          String guid)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          PropertyServerException
```
    Restore a Antonym relationship
    Restore allows the deleted Antonym relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Antonym relationship to delete
    
    Returns:
    
    the restored Antonym relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - createTranslationRelationship
```
public Translation createTranslationRelationship(String userId,
                                                 Translation translation)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 PropertyServerException
```
    Create a Translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    translation - the Translation relationship
    
    Returns:
    
    the created translation relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getTranslationRelationship
```
public Translation getTranslationRelationship(String userId,
                                              String guid)
                                       throws InvalidParameterException,
                                              UserNotAuthorizedException,
                                              PropertyServerException
```
    Get a translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Translation relationship to get
    
    Returns:
    
    Translation
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - updateTranslationRelationship
```
public Translation updateTranslationRelationship(String userId,
                                                 String guid,
                                                 Translation translation)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 PropertyServerException
```
    Update a Translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the Translation relationship
    
    translation - the Translation relationship
    
    Returns:
    
    Translation updated translation
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - replaceTranslationRelationship
```
public Translation replaceTranslationRelationship(String userId,
                                                  String guid,
                                                  Translation translation)
                                           throws InvalidParameterException,
                                                  UserNotAuthorizedException,
                                                  PropertyServerException
```
    Replace an Translation relationship, which is link between glossary terms that provide different natural language translation of the same concept.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the Translation relationship
    
    translation - the translation relationship
    
    Returns:
    
    Translation replaced translation
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deleteTranslationRelationship
```
public void deleteTranslationRelationship(String userId,
                                          String guid)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          PropertyServerException
```
    Delete a translation relationship, which is link between glossary terms that provide different natural language translation of the same concept. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Translation relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - restoreTranslationRelationship
```
public Translation restoreTranslationRelationship(String userId,
                                                  String guid)
                                           throws InvalidParameterException,
                                                  UserNotAuthorizedException,
                                                  PropertyServerException
```
    Restore a Translation relationship
    Restore allows the deleted Translation relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Translation relationship to delete
    
    Returns:
    
    the restored Translation relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - createUsedInContextRelationship
```
public UsedInContext createUsedInContextRelationship(String userId,
                                                     UsedInContext usedInContext)
                                              throws InvalidParameterException,
                                                     UserNotAuthorizedException,
                                                     PropertyServerException
```
    Create a UsedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    usedInContext - the UsedInContext relationship
    
    Returns:
    
    the created usedInContext relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getUsedInContextRelationship
```
public UsedInContext getUsedInContextRelationship(String userId,
                                                  String guid)
                                           throws InvalidParameterException,
                                                  UserNotAuthorizedException,
                                                  PropertyServerException
```
    Get a usedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the UsedInContext relationship to get
    
    Returns:
    
    UsedInContext
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - updateUsedInContextRelationship
```
public UsedInContext updateUsedInContextRelationship(String userId,
                                                     String guid,
                                                     UsedInContext usedInContext)
                                              throws InvalidParameterException,
                                                     UserNotAuthorizedException,
                                                     PropertyServerException
```
    Update a UsedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the UsedInContext relationship
    
    usedInContext - the UsedInContext relationship
    
    Returns:
    
    UsedInContext updated usedInContext
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - replaceUsedInContextRelationship
```
public UsedInContext replaceUsedInContextRelationship(String userId,
                                                      String guid,
                                                      UsedInContext usedInContext)
                                               throws InvalidParameterException,
                                                      UserNotAuthorizedException,
                                                      PropertyServerException
```
    Replace an UsedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the UsedInContext relationship
    
    usedInContext - the usedInContext relationship
    
    Returns:
    
    UsedInContext replaced usedInContext
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deleteUsedInContextRelationship
```
public void deleteUsedInContextRelationship(String userId,
                                            String guid)
                                     throws InvalidParameterException,
                                            UserNotAuthorizedException,
                                            PropertyServerException
```
    Delete a usedInContext relationship, which is link between glossary terms where on describes the context where the other one is valid to use. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the UsedInContext relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - restoreUsedInContextRelationship
```
public UsedInContext restoreUsedInContextRelationship(String userId,
                                                      String guid)
                                               throws InvalidParameterException,
                                                      UserNotAuthorizedException,
                                                      PropertyServerException
```
    Restore a Used in context relationship
    Restore allows the deletedUsed in context relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Used in context relationship to delete
    
    Returns:
    
    the restored Used in context relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - createPreferredTermRelationship
```
public PreferredTerm createPreferredTermRelationship(String userId,
                                                     PreferredTerm preferredTerm)
                                              throws InvalidParameterException,
                                                     UserNotAuthorizedException,
                                                     PropertyServerException
```
    Create a PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    preferredTerm - the PreferredTerm relationship
    
    Returns:
    
    the created preferredTerm relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getPreferredTermRelationship
```
public PreferredTerm getPreferredTermRelationship(String userId,
                                                  String guid)
                                           throws InvalidParameterException,
                                                  UserNotAuthorizedException,
                                                  PropertyServerException
```
    Get a preferredTerm relationship, which is link to an alternative term that the organization prefer is used.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the PreferredTerm relationship to get
    
    Returns:
    
    PreferredTerm
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - updatePreferredTermRelationship
```
public PreferredTerm updatePreferredTermRelationship(String userId,
                                                     String guid,
                                                     PreferredTerm preferredTerm)
                                              throws InvalidParameterException,
                                                     UserNotAuthorizedException,
                                                     PropertyServerException
```
    Update a PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the PreferredTerm relationship
    
    preferredTerm - the PreferredTerm relationship
    
    Returns:
    
    PreferredTerm updated preferredTerm
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - replacePreferredTermRelationship
```
public PreferredTerm replacePreferredTermRelationship(String userId,
                                                      String guid,
                                                      PreferredTerm preferredTerm)
                                               throws InvalidParameterException,
                                                      UserNotAuthorizedException,
                                                      PropertyServerException
```
    Replace an PreferredTerm relationship, which is link to an alternative term that the organization prefer is used.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the PreferredTerm relationship
    
    preferredTerm - the preferredTerm relationship
    
    Returns:
    
    PreferredTerm replaced preferredTerm
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deletePreferredTermRelationship
```
public void deletePreferredTermRelationship(String userId,
                                            String guid)
                                     throws InvalidParameterException,
                                            UserNotAuthorizedException,
                                            PropertyServerException
```
    Delete a preferredTerm relationship, which is link to an alternative term that the organization prefer is used. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the PreferredTerm relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - restorePreferredTermRelationship
```
public PreferredTerm restorePreferredTermRelationship(String userId,
                                                      String guid)
                                               throws InvalidParameterException,
                                                      UserNotAuthorizedException,
                                                      PropertyServerException
```
    Restore a preferred term relationship
    Restore allows the deletedpreferred term relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the preferred term relationship to delete
    
    Returns:
    
    the restored preferred term relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - createValidValueRelationship
```
public ValidValue createValidValueRelationship(String userId,
                                               ValidValue validValue)
                                        throws InvalidParameterException,
                                               UserNotAuthorizedException,
                                               PropertyServerException
```
    Create a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    validValue - the ValidValue relationship
    
    Returns:
    
    the created validValue relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getValidValueRelationship
```
public ValidValue getValidValueRelationship(String userId,
                                            String guid)
                                     throws InvalidParameterException,
                                            UserNotAuthorizedException,
                                            PropertyServerException
```
    Get a validValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ValidValue relationship to get
    
    Returns:
    
    ValidValue
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - updateValidValueRelationship
```
public ValidValue updateValidValueRelationship(String userId,
                                               String guid,
                                               ValidValue validValue)
                                        throws InvalidParameterException,
                                               UserNotAuthorizedException,
                                               PropertyServerException
```
    Update a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the ValidValue relationship
    
    validValue - the ValidValue relationship
    
    Returns:
    
    ValidValue updated validValue
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - replaceValidValueRelationship
```
public ValidValue replaceValidValueRelationship(String userId,
                                                String guid,
                                                ValidValue validValue)
                                         throws InvalidParameterException,
                                                UserNotAuthorizedException,
                                                PropertyServerException
```
    Replace an ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the ValidValue relationship
    
    validValue - the validValue relationship
    
    Returns:
    
    ValidValue replaced validValue
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deleteValidValueRelationship
```
public void deleteValidValueRelationship(String userId,
                                         String guid)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
```
    Delete a validValue relationship, which is link between glossary terms where one defines one of the data values for the another. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ValidValue relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - restoreValidValueRelationship
```
public ValidValue restoreValidValueRelationship(String userId,
                                                String guid)
                                         throws InvalidParameterException,
                                                UserNotAuthorizedException,
                                                PropertyServerException
```
    Restore a valid value relationship
    Restore allows the deletedvalid value relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the valid value relationship to delete
    
    Returns:
    
    the restored valid value relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - createReplacementTermRelationship
```
public ReplacementTerm createReplacementTermRelationship(String userId,
                                                         ReplacementTerm replacementTerm)
                                                  throws InvalidParameterException,
                                                         UserNotAuthorizedException,
                                                         PropertyServerException
```
    Create a ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    replacementTerm - the ReplacementTerm relationship
    
    Returns:
    
    the created replacementTerm relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getReplacementTermRelationship
```
public ReplacementTerm getReplacementTermRelationship(String userId,
                                                      String guid)
                                               throws InvalidParameterException,
                                                      UserNotAuthorizedException,
                                                      PropertyServerException
```
    Get a replacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ReplacementTerm relationship to get
    
    Returns:
    
    ReplacementTerm
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - updateReplacementTermRelationship
```
public ReplacementTerm updateReplacementTermRelationship(String userId,
                                                         String guid,
                                                         ReplacementTerm replacementTerm)
                                                  throws InvalidParameterException,
                                                         UserNotAuthorizedException,
                                                         PropertyServerException
```
    Update a ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the ReplacementTerm relationship
    
    replacementTerm - the ReplacementTerm relationship
    
    Returns:
    
    ReplacementTerm updated replacementTerm
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - replaceReplacementTermRelationship
```
public ReplacementTerm replaceReplacementTermRelationship(String userId,
                                                          String guid,
                                                          ReplacementTerm replacementTerm)
                                                   throws InvalidParameterException,
                                                          UserNotAuthorizedException,
                                                          PropertyServerException
```
    Replace an ReplacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the ReplacementTerm relationship
    
    replacementTerm - the replacementTerm relationship
    
    Returns:
    
    ReplacementTerm replaced replacementTerm
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deleteReplacementTermRelationship
```
public void deleteReplacementTermRelationship(String userId,
                                              String guid)
                                       throws InvalidParameterException,
                                              UserNotAuthorizedException,
                                              PropertyServerException
```
    Delete a replacementTerm relationship, which is link to a glossary term that is replacing an obsolete glossary term. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ReplacementTerm relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - restoreReplacementTermRelationship
```
public ReplacementTerm restoreReplacementTermRelationship(String userId,
                                                          String guid)
                                                   throws InvalidParameterException,
                                                          UserNotAuthorizedException,
                                                          PropertyServerException
```
    Restore a replacement term relationship
    Restore allows the deleted replacement term relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the replacement term relationship to delete
    
    Returns:
    
    the restored replacement term relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - createTermTYPEDBYRelationship
```
public TypedBy createTermTYPEDBYRelationship(String userId,
                                             TypedBy termTYPEDBYRelationship)
                                      throws InvalidParameterException,
                                             UserNotAuthorizedException,
                                             PropertyServerException
```
    Create a TypedBy relationship, which is defines the relationship between a spine attribute and its type.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    termTYPEDBYRelationship - the TypedBy relationship
    
    Returns:
    
    the created termTYPEDBYRelationship relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getTermTYPEDBYRelationship
```
public TypedBy getTermTYPEDBYRelationship(String userId,
                                          String guid)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          PropertyServerException
```
    Get a termTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the termTYPEDBYRelationship relationship to get
    
    Returns:
    
    TypedBy
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - updateTermTYPEDBYRelationship
```
public TypedBy updateTermTYPEDBYRelationship(String userId,
                                             String guid,
                                             TypedBy termTYPEDBYRelationship)
                                      throws InvalidParameterException,
                                             UserNotAuthorizedException,
                                             PropertyServerException
```
    Update a TypedBy relationship, which is defines the relationship between a spine attribute and its type.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the TypedBy relationship
    
    termTYPEDBYRelationship - the TypedBy relationship
    
    Returns:
    
    TypedBy updated termTYPEDBYRelationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - replaceTermTYPEDBYRelationship
```
public TypedBy replaceTermTYPEDBYRelationship(String userId,
                                              String guid,
                                              TypedBy termTYPEDBYRelationship)
                                       throws InvalidParameterException,
                                              UserNotAuthorizedException,
                                              PropertyServerException
```
    Replace an TypedBy relationship, which is defines the relationship between a spine attribute and its type.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the TypedBy relationship
    
    termTYPEDBYRelationship - the termTYPEDBYRelationship relationship
    
    Returns:
    
    TypedBy replaced termTYPEDBYRelationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deleteTermTYPEDBYRelationship
```
public void deleteTermTYPEDBYRelationship(String userId,
                                          String guid)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          PropertyServerException
```
    Delete a termTYPEDBYRelationship relationship, which is defines the relationship between a spine attribute and its type. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the termTYPEDBYRelationship relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - restoreTypedByRelationship
```
public TypedBy restoreTypedByRelationship(String userId,
                                          String guid)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          PropertyServerException
```
    Restore a typed by relationship
    Restore allows the deleted typed by relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the typed by relationship to delete
    
    Returns:
    
    the restored typed by relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - createIsaRelationship
```
public IsA createIsaRelationship(String userId,
                                 IsA isa)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 PropertyServerException
```
    Create a Isa relationship, which is link between a more general glossary term and a more specific definition.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    isa - the Isa relationship
    
    Returns:
    
    the created isa relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getIsaRelationship
```
public IsA getIsaRelationship(String userId,
                              String guid)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              PropertyServerException
```
    Get a isa relationship, which is link between a more general glossary term and a more specific definition.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the isa relationship to get
    
    Returns:
    
    Isa
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - updateIsaRelationship
```
public IsA updateIsaRelationship(String userId,
                                 String guid,
                                 IsA isa)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 PropertyServerException
```
    Update a Isa relationship, which is link between a more general glossary term and a more specific definition.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the isa relationship
    
    isa - the Isa relationship
    
    Returns:
    
    Isa updated isa
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - replaceIsaRelationship
```
public IsA replaceIsaRelationship(String userId,
                                  String guid,
                                  IsA isa)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException
```
    Replace an Isa relationship, which is link between a more general glossary term and a more specific definition.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the isa relationship
    
    isa - the isa relationship
    
    Returns:
    
    Isa replaced isa
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deleteIsaRelationship
```
public void deleteIsaRelationship(String userId,
                                  String guid)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException
```
    Delete a isa relationship, which is link between a more general glossary term and a more specific definition. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the isa relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - restoreIsaRelationship
```
public IsA restoreIsaRelationship(String userId,
                                  String guid)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException
```
    Restore an is a relationship
    Restore allows the deleted is a relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the is a relationship to delete
    
    Returns:
    
    the restored is a relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - createIsATypeOfDeprecated
```
public IsATypeOfDeprecated createIsATypeOfDeprecated(String userId,
                                                     IsATypeOfDeprecated isATypeOf)
                                              throws InvalidParameterException,
                                                     UserNotAuthorizedException,
                                                     PropertyServerException
```
    Create a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    isATypeOf - the IsaTypeOf relationship
    
    Returns:
    
    the created IsaTypeOf relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getIsATypeOfDeprecated
```
public IsATypeOfDeprecated getIsATypeOfDeprecated(String userId,
                                                  String guid)
                                           throws InvalidParameterException,
                                                  UserNotAuthorizedException,
                                                  PropertyServerException
```
    Get a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the IsaTypeOf relationship to get
    
    Returns:
    
    IsaTypeOf
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - updateIsATypeOfDeprecated
```
public IsATypeOfDeprecated updateIsATypeOfDeprecated(String userId,
                                                     String guid,
                                                     IsATypeOfDeprecated isATypeOf)
                                              throws InvalidParameterException,
                                                     UserNotAuthorizedException,
                                                     PropertyServerException
```
    Update a IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the IsaTypeOf relationship
    
    isATypeOf - the IsaTypeOf relationship
    
    Returns:
    
    IsaTypeOf updated IsaTypeOf
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - replaceIsATypeOfDeprecated
```
public IsATypeOfDeprecated replaceIsATypeOfDeprecated(String userId,
                                                      String guid,
                                                      IsATypeOfDeprecated isATypeOf)
                                               throws InvalidParameterException,
                                                      UserNotAuthorizedException,
                                                      PropertyServerException
```
    Replace an IsaTypeOf relationship, which is defines an inheritance relationship between two spine objects.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the IsaTypeOf relationship
    
    isATypeOf - the IsaTypeOf relationship
    
    Returns:
    
    IsaTypeOf replaced IsaTypeOf
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deleteIsATypeOfDeprecated
```
public void deleteIsATypeOfDeprecated(String userId,
                                      String guid)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      PropertyServerException
```
    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.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the IsaTypeOf relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - restoreIsaTypeOfDeprecated
```
public IsATypeOfDeprecated restoreIsaTypeOfDeprecated(String userId,
                                                      String guid)
                                               throws InvalidParameterException,
                                                      UserNotAuthorizedException,
                                                      PropertyServerException
```
    Deprecated.
    
    Restore an is a type of deprecated relationship
    Restore allows the deleted is a type of relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the is a type of relationship to delete
    
    Returns:
    
    the restored is a type of relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - createIsATypeOf
```
public IsATypeOf createIsATypeOf(String userId,
                                 IsATypeOf IsATypeOf)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 PropertyServerException
```
    Create a IsATypeOf relationship, which is defines an inheritance relationship between two spine objects.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    IsATypeOf - the IsATypeOf relationship
    
    Returns:
    
    the createdIsATypeOf relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getIsATypeOf
```
public IsATypeOf getIsATypeOf(String userId,
                              String guid)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              PropertyServerException
```
    Get a IsATypeOf relationship, which is defines an inheritance relationship between two spine objects.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the IsATypeOf relationship to get
    
    Returns:
    
    IsATypeOf
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - updateIsATypeOf
```
public IsATypeOf updateIsATypeOf(String userId,
                                 String guid,
                                 IsATypeOf IsATypeOf)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 PropertyServerException
```
    Update a IsATypeOf relationship, which is defines an inheritance relationship between two spine objects.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the IsATypeOf relationship
    
    IsATypeOf - the IsATypeOf relationship
    
    Returns:
    
    IsATypeOf updatedIsATypeOf
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - replaceIsATypeOf
```
public IsATypeOf replaceIsATypeOf(String userId,
                                  String guid,
                                  IsATypeOf IsATypeOf)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException
```
    Replace anIsATypeOf relationship, which is defines an inheritance relationship between two spine objects.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the IsATypeOf relationship
    
    IsATypeOf - the IsATypeOf relationship
    
    Returns:
    
    IsATypeOf replacedIsATypeOf
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deleteIsATypeOf
```
public void deleteIsATypeOf(String userId,
                            String guid)
                     throws InvalidParameterException,
                            UserNotAuthorizedException,
                            PropertyServerException
```
    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.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the IsATypeOf relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - restoreIsATypeOf
```
public IsATypeOf restoreIsATypeOf(String userId,
                                  String guid)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException
```
    Restore an is a type of relationship
    Restore allows the deleted is a type of relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the is a type of relationship to delete
    
    Returns:
    
    the restored is a type of relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - createTermCategorizationRelationship
```
public Categorization createTermCategorizationRelationship(String userId,
                                                           Categorization termCategorizationRelationship)
                                                    throws InvalidParameterException,
                                                           UserNotAuthorizedException,
                                                           PropertyServerException
```
    Create a Term Categorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized. Note that this method does not error if the relationship ends are not spine objects or spine attributes.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    termCategorizationRelationship - the term categorization relationship
    
    Returns:
    
    the created term categorization relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getTermCategorizationRelationship
```
public Categorization getTermCategorizationRelationship(String userId,
                                                        String guid)
                                                 throws InvalidParameterException,
                                                        UserNotAuthorizedException,
                                                        PropertyServerException
```
    Get a Term Categorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermCategorizationRelationship relationship to get
    
    Returns:
    
    TermCategorizationRelationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - updateTermCategorizationRelationship
```
public Categorization updateTermCategorizationRelationship(String userId,
                                                           String guid,
                                                           Categorization termCategorizationRelationship)
                                                    throws InvalidParameterException,
                                                           UserNotAuthorizedException,
                                                           PropertyServerException
```
    Update a Term Categorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the TermCategorizationRelationship
    
    termCategorizationRelationship - the term categorization relationship
    
    Returns:
    
    the updated term categorization relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - replaceTermCategorizationRelationship
```
public Categorization replaceTermCategorizationRelationship(String userId,
                                                            String guid,
                                                            Categorization termCategorizationRelationship)
                                                     throws InvalidParameterException,
                                                            UserNotAuthorizedException,
                                                            PropertyServerException
```
    Replace a Term HasA Relationship.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the TermCategorizationRelationship
    
    termCategorizationRelationship - the term categorization relationship
    
    Returns:
    
    the replaced term categorization relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deleteTermCategorizationRelationship
```
public void deleteTermCategorizationRelationship(String userId,
                                                 String guid)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 PropertyServerException
```
    Delete a Term Categorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized. * A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermCategorizationRelationship relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - restoreTermCategorizationRelationship
```
public Categorization restoreTermCategorizationRelationship(String userId,
                                                            String guid)
                                                     throws InvalidParameterException,
                                                            UserNotAuthorizedException,
                                                            PropertyServerException
```
    Restore a Term Categorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.
    Restore allows the deleted Term Categorization relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Term Categorization relationship to delete
    
    Returns:
    
    the restored has a relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getTermAnchorRelationship
```
public TermAnchor getTermAnchorRelationship(String userId,
                                            String guid)
                                     throws InvalidParameterException,
                                            UserNotAuthorizedException,
                                            PropertyServerException
```
    Get a Term Anchor Relationship. A relationship between a Glossary and a Term. This relationship allows terms to be owned by a glossary.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermAnchorRelationship relationship to get
    
    Returns:
    
    TermAnchorRelationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - getCategoryAnchorRelationship
```
public CategoryAnchor getCategoryAnchorRelationship(String userId,
                                                    String guid)
                                             throws InvalidParameterException,
                                                    UserNotAuthorizedException,
                                                    PropertyServerException
```
    Get a Category Anchor Relationship. A relationship between a Glossary and a Category. This relationship allows categoriess to be owned by a glossary.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the CategoryAnchorRelationship relationship to get
    
    Returns:
    
    CategoryAnchorRelationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - createProjectScopeRelationship
```
public ProjectScope createProjectScopeRelationship(String userId,
                                                   ProjectScope projectScope)
                                            throws InvalidParameterException,
                                                   UserNotAuthorizedException,
                                                   PropertyServerException
```
    Create a ProjectScope relationship. A link between the project content and the project.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    projectScope - the ProjectScope relationship
    
    Returns:
    
    the created ProjectScope relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getProjectScopeRelationship
```
public ProjectScope getProjectScopeRelationship(String userId,
                                                String guid)
                                         throws InvalidParameterException,
                                                UserNotAuthorizedException,
                                                PropertyServerException
```
    Get a ProjectScope relationship. A link between the project content and the project.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ProjectScope relationship to get
    
    Returns:
    
    ProjectScope
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - updateProjectScopeRelationship
```
public ProjectScope updateProjectScopeRelationship(String userId,
                                                   String guid,
                                                   ProjectScope projectScopeRelationship)
                                            throws InvalidParameterException,
                                                   UserNotAuthorizedException,
                                                   PropertyServerException
```
    Update a ProjectScope relationship which is a link between the project content and the project.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the ProjectScope relationship
    
    projectScopeRelationship - the ProjectScope relationship
    
    Returns:
    
    updated ProjectScope relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - replaceProjectScopeRelationship
```
public ProjectScope replaceProjectScopeRelationship(String userId,
                                                    String guid,
                                                    ProjectScope projectScopeRelationship)
                                             throws InvalidParameterException,
                                                    UserNotAuthorizedException,
                                                    PropertyServerException
```
    Replace a ProjectScope relationship which is a link between the project content and the project.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the ProjectScope relationship
    
    projectScopeRelationship - the ProjectScope relationship
    
    Returns:
    
    replaced ProjectScope relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deleteProjectScopeRelationship
```
public void deleteProjectScopeRelationship(String userId,
                                           String guid)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           PropertyServerException
```
    Delete a ProjectScope relationship. A link between the project content and the project. A delete (also known as a soft delete) means that the relationship instance will exist in a deleted state in the repository after the delete operation. This means that it is possible to undo the delete.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ProjectScope relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid.
    
    PropertyServerException - Property server exception
  - restoreProjectScopeRelationship
```
public ProjectScope restoreProjectScopeRelationship(String userId,
                                                    String guid)
                                             throws InvalidParameterException,
                                                    UserNotAuthorizedException,
                                                    PropertyServerException
```
    Restore a ProjectScope relationship which is a link between the project content and the project.
    Restore allows the deleted ProjectScope relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ProjectScope relationship to restore
    
    Returns:
    
    the restored ProjectScope relationship
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - createCategoryHierarchyLink
```
public CategoryHierarchyLink createCategoryHierarchyLink(String userId,
                                                         CategoryHierarchyLink categoryHierarchyLink)
                                                  throws InvalidParameterException,
                                                         PropertyServerException,
                                                         UserNotAuthorizedException
```
    Create a CategoryHierarchyLink Relationship. A relationship between two categories used to create nested categories.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    categoryHierarchyLink - the CategoryHierarchyLink relationship
    
    Returns:
    
    CategoryHierarchyLink the created CategoryHierarchyLink
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getCategoryHierarchyLink
```
public CategoryHierarchyLink getCategoryHierarchyLink(String userId,
                                                      String guid)
                                               throws InvalidParameterException,
                                                      PropertyServerException,
                                                      UserNotAuthorizedException
```
    Get a CategoryHierarchyLink Relationship. A relationship between two categories used to create nested categories.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the CategoryHierarchyLink Relationship to get
    
    Returns:
    
    the CategoryHierarchyLink relationship with the requested guid
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - updateCategoryHierarchyLink
```
public CategoryHierarchyLink updateCategoryHierarchyLink(String userId,
                                                         String guid,
                                                         CategoryHierarchyLink categoryHierarchyLink)
                                                  throws InvalidParameterException,
                                                         PropertyServerException,
                                                         UserNotAuthorizedException
```
    Update a CategoryHierarchyLink Relationship. A relationship between two categories used to create nested categories.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the CategoryHierarchyLink Relationship to update
    
    categoryHierarchyLink - the CategoryHierarchyLink relationship
    
    Returns:
    
    the updated categoryHierarchyLink
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - replaceCategoryHierarchyLink
```
public CategoryHierarchyLink replaceCategoryHierarchyLink(String userId,
                                                          String guid,
                                                          CategoryHierarchyLink categoryHierarchyLink)
                                                   throws InvalidParameterException,
                                                          PropertyServerException,
                                                          UserNotAuthorizedException
```
    Replace a CategoryHierarchyLink Relationship. A relationship between two categories used to create nested categories.
    
    Parameters:
    
    userId - userId under which the request is performed
    
    guid - guid of the CategoryHierarchyLink Relationship to update
    
    categoryHierarchyLink - the CategoryHierarchyLink relationship
    
    Returns:
    
    the replaced categoryHierarchyLink
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - deleteCategoryHierarchyLink
```
public void deleteCategoryHierarchyLink(String userId,
                                        String guid)
                                 throws InvalidParameterException,
                                        PropertyServerException,
                                        UserNotAuthorizedException
```
    Delete a CategoryHierarchyLink Relationship. A relationship between two categories used to create nested categories.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the CategoryHierarchyLink relationship to delete
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - restoreCategoryHierarchyLink
```
public CategoryHierarchyLink restoreCategoryHierarchyLink(String userId,
                                                          String guid)
                                                   throws InvalidParameterException,
                                                          PropertyServerException,
                                                          UserNotAuthorizedException
```
    Restore a CategoryHierarchyLink Relationship. A relationship between two categories used to create nested categories.
    Restore allows the deleted CategoryHierarchyLink Relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    
    Parameters:
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the CategoryHierarchyLink Relationship to restore
    
    Returns:
    
    the restored CategoryHierarchyLink
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception
  - getSemanticAssignmentRelationship
```
public SemanticAssignment getSemanticAssignmentRelationship(String userId,
                                                            String guid)
                                                     throws InvalidParameterException,
                                                            UserNotAuthorizedException,
                                                            PropertyServerException
```
    Get a SemanticAssignment relationship, Links a glossary term to another element such as an asset or schema element to define its meaning.
    
    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
    
    Throws:
    
    UserNotAuthorizedException - the requesting user is not authorized to issue this request.
    
    InvalidParameterException - one of the parameters is null or invalid
    
    PropertyServerException - Property server exception

Class RelationshipHandler

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

RelationshipHandler

Method Detail

createTermHasARelationship

getTermHasARelationship

updateTermHasARelationship

replaceTermHasARelationship

deleteTermHasARelationship

restoreTermHasARelationship

createRelatedTerm

getRelatedTerm

updateRelatedTerm

replaceRelatedTerm

restoreRelatedTerm

deleteRelatedTerm

restoreRelatedTermRelationship

createSynonymRelationship

getSynonymRelationship

updateSynonymRelationship

replaceSynonymRelationship

deleteSynonymRelationship

restoreSynonymRelationship

createAntonymRelationship

getAntonymRelationship

updateAntonymRelationship

replaceAntonymRelationship

deleteAntonymRelationship

restoreAntonymRelationship

createTranslationRelationship

getTranslationRelationship

updateTranslationRelationship

replaceTranslationRelationship

deleteTranslationRelationship

restoreTranslationRelationship

createUsedInContextRelationship

getUsedInContextRelationship

updateUsedInContextRelationship

replaceUsedInContextRelationship

deleteUsedInContextRelationship

restoreUsedInContextRelationship

createPreferredTermRelationship

getPreferredTermRelationship

updatePreferredTermRelationship

replacePreferredTermRelationship

deletePreferredTermRelationship

restorePreferredTermRelationship

createValidValueRelationship

getValidValueRelationship

updateValidValueRelationship

replaceValidValueRelationship

deleteValidValueRelationship

restoreValidValueRelationship

createReplacementTermRelationship

getReplacementTermRelationship

updateReplacementTermRelationship

replaceReplacementTermRelationship

deleteReplacementTermRelationship

restoreReplacementTermRelationship

createTermTYPEDBYRelationship

getTermTYPEDBYRelationship

updateTermTYPEDBYRelationship

replaceTermTYPEDBYRelationship

deleteTermTYPEDBYRelationship

restoreTypedByRelationship

createIsaRelationship

getIsaRelationship

updateIsaRelationship

replaceIsaRelationship

deleteIsaRelationship

restoreIsaRelationship

createIsATypeOfDeprecated

getIsATypeOfDeprecated

updateIsATypeOfDeprecated

replaceIsATypeOfDeprecated

deleteIsATypeOfDeprecated

restoreIsaTypeOfDeprecated