GlossaryAuthorViewRelationshipRESTResource (glossary-author-view-spring 1.7 API)

java.lang.Object
- org.odpi.openmetadata.viewservices.glossaryauthor.server.GlossaryAuthorViewRelationshipRESTResource

```
@RestController
 @RequestMapping(value="/servers/{serverName}/open-metadata/view-services/glossary-author/users/{userId}/relationships")
public class GlossaryAuthorViewRelationshipRESTResource
extends Object
```
The GlossaryAuthorRESTServicesInstance provides the org.odpi.openmetadata.viewservices.glossaryauthor.server implementation of the Glossary Author Open Metadata View Service (OMVS) for relationships. This interface provides relationship authoring interfaces for subject area experts.

Constructor Summary

Constructors
Constructor and Description

GlossaryAuthorViewRelationshipRESTResource()
Default constructor

Constructors
Constructor and Description
`GlossaryAuthorViewRelationshipRESTResource()` Default constructor

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`SubjectAreaOMASAPIResponse`	`createAntonym(String serverName, String userId, Antonym antonym)` Create an antonym relationship, which is a link between glossary terms that have the opposite meaning.
`SubjectAreaOMASAPIResponse`	`createCategoryAnchor(String serverName, String userId, CategoryAnchorRelationship categoryAnchorRelationship)` Create a categoryAnchor Relationship.
`SubjectAreaOMASAPIResponse`	`createiSA(String serverName, String userId, ISARelationship iSARelationship)` Create a iSARelationship relationship, which is a link between a more general glossary term and a more specific definition.
`SubjectAreaOMASAPIResponse`	`createpreferredTerm(String serverName, String userId, PreferredTerm preferredTerm)` Create a preferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.
`SubjectAreaOMASAPIResponse`	`createProjectScope(String serverName, String userId, ProjectScopeRelationship projectScope)` Create a project scope relationship, which is a link between the project content and the project.
`SubjectAreaOMASAPIResponse`	`createRelatedTerm(String serverName, String userId, RelatedTerm relatedTermRelationshipRelationship)` Create a RelatedTerm.
`SubjectAreaOMASAPIResponse`	`createreplacementTerm(String serverName, String userId, ReplacementTerm replacementTerm)` Create a replacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.
`SubjectAreaOMASAPIResponse`	`createSynonym(String serverName, String userId, Synonym synonym)` Create a synonym relationship, which is a link between glossary terms that have the same meaning.
`SubjectAreaOMASAPIResponse`	`createTermAnchor(String serverName, String userId, TermAnchorRelationship termAnchorRelationship)` Create a termAnchor Relationship.
`SubjectAreaOMASAPIResponse`	`createTermCategorization(String serverName, String userId, TermCategorizationRelationship termCategorizationRelationship)` Create a termCategorization Relationship.
`SubjectAreaOMASAPIResponse`	`createTermHASA(String serverName, String userId, TermHASARelationship termHASARelationship)` Create a TermHASARelationship is the relationship between a spine object and a spine attribute.
`SubjectAreaOMASAPIResponse`	`createtermISATypeOF(String serverName, String userId, TermISATypeOFRelationship termISATypeOFRelationship)` Create a termISATypeOFRelationship relationship, which is an inheritance relationship between two spine objects.
`SubjectAreaOMASAPIResponse`	`createtermTYPEDBY(String serverName, String userId, TermTYPEDBYRelationship termTYPEDBYRelationship)` Create a termTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.
`SubjectAreaOMASAPIResponse`	`createTranslation(String serverName, String userId, Translation translation)` Create a translation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.
`SubjectAreaOMASAPIResponse`	`createusedInContext(String serverName, String userId, UsedInContext usedInContext)` Create a usedInContext relationship, which is a link between glossary terms, where one describes the context where the other one is valid to use.
`SubjectAreaOMASAPIResponse`	`createvalidValue(String serverName, String userId, ValidValue validValue)` Create a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
`SubjectAreaOMASAPIResponse`	`deleteAntonym(String serverName, String userId, String guid, Boolean isPurge)` Delete a Antonym relationship
`SubjectAreaOMASAPIResponse`	`deleteCategoryAnchor(String serverName, String userId, String guid, Boolean isPurge)` Delete a CategoryAnchor Relationship.
`SubjectAreaOMASAPIResponse`	`deletePreferredTerm(String serverName, String userId, String guid, Boolean isPurge)` Delete a PreferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.
`SubjectAreaOMASAPIResponse`	`deleteProjectScope(String serverName, String userId, String guid, Boolean isPurge)` Delete a Project scope relationship which is a link between the project content and the project.
`SubjectAreaOMASAPIResponse`	`deleteRelatedTerm(String serverName, String userId, String guid, Boolean isPurge)` Delete a Related Term relationship
`SubjectAreaOMASAPIResponse`	`deleteReplacementTerm(String serverName, String userId, String guid, Boolean isPurge)` Delete a ReplacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.
`SubjectAreaOMASAPIResponse`	`deleteSynonym(String serverName, String userId, String guid, Boolean isPurge)` Delete a Synonym relationship
`SubjectAreaOMASAPIResponse`	`deleteTermAnchor(String serverName, String userId, String guid, Boolean isPurge)` Delete a TermAnchor Relationship.
`SubjectAreaOMASAPIResponse`	`deleteTermCategorization(String serverName, String userId, String guid, Boolean isPurge)` Delete a TermCategorization Relationship.
`SubjectAreaOMASAPIResponse`	`deleteTermHASA(String serverName, String userId, String guid, Boolean isPurge)` Delete a Term HAS A relationship
`SubjectAreaOMASAPIResponse`	`deleteTermISA(String serverName, String userId, String guid, Boolean isPurge)` Delete a ISA relationship, which is a link between a more general glossary term and a more specific definition.
`SubjectAreaOMASAPIResponse`	`deleteTermIsaTypeOf(String serverName, String userId, String guid, Boolean isPurge)` Delete a TermISATypeOFRelationship relationship, which is an inheritance relationship between two spine objects.
`SubjectAreaOMASAPIResponse`	`deleteTranslation(String serverName, String userId, String guid, Boolean isPurge)` Delete a Translation relationshiptranslation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.
`SubjectAreaOMASAPIResponse`	`deleteTypedBy(String serverName, String userId, String guid, Boolean isPurge)` Delete a TermTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.
`SubjectAreaOMASAPIResponse`	`deleteUsedInContext(String serverName, String userId, String guid, Boolean isPurge)` Delete a UsedInContext relationship which is a link between glossary terms, where one describes the context where the other one is valid to use.
`SubjectAreaOMASAPIResponse`	`deleteValidValue(String serverName, String userId, String guid, Boolean isPurge)` Delete a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
`SubjectAreaOMASAPIResponse`	`getAntonym(String serverName, String userId, String guid)` Get a antonym relationship
`SubjectAreaOMASAPIResponse`	`getCategoryAnchor(String serverName, String userId, String guid)` Get a categoryAnchor Relationship.
`SubjectAreaOMASAPIResponse`	`getISA(String serverName, String userId, String guid)` Get a ISA relationship, which is a link between a more general glossary term and a more specific definition.
`SubjectAreaOMASAPIResponse`	`getPreferredTerm(String serverName, String userId, String guid)` Get a preferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.
`SubjectAreaOMASAPIResponse`	`getProjectScope(String serverName, String userId, String guid)` Get a project scope relationship, which is a link between the project content and the project.
`SubjectAreaOMASAPIResponse`	`getRelatedTerm(String serverName, String userId, String guid)` Get a related Term relationship.
`SubjectAreaOMASAPIResponse`	`getReplacementTerm(String serverName, String userId, String guid)` Get a replacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.
`SubjectAreaOMASAPIResponse`	`getSemanticAssignment(String serverName, String userId, String guid)` Get a SemanticAssignment relationship, Links a glossary term to another element such as an asset or schema element to define its meaning.
`SubjectAreaOMASAPIResponse`	`getSynonym(String serverName, String userId, String guid)` Get a synonym relationship, which is a link between glossary terms that have the same meaning.
`SubjectAreaOMASAPIResponse`	`getTermAnchor(String serverName, String userId, String guid)` Get a termAnchor Relationship.
`SubjectAreaOMASAPIResponse`	`getTermCategorization(String serverName, String userId, String guid)` Get a termCategorization Relationship.
`SubjectAreaOMASAPIResponse`	`getTermHASA(String serverName, String userId, String guid)` Get a Term HAS A relationship
`SubjectAreaOMASAPIResponse`	`getTermISATypeOF(String serverName, String userId, String guid)` Get a termISATypeOFRelationship relationship, which is an inheritance relationship between two spine objects.
`SubjectAreaOMASAPIResponse`	`getTranslation(String serverName, String userId, String guid)` Get a translation relationshiptranslation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.
`SubjectAreaOMASAPIResponse`	`getTYPEDBY(String serverName, String userId, String guid)` Get a termTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.
`SubjectAreaOMASAPIResponse`	`getUsedInContext(String serverName, String userId, String guid)` Get a usedInContext relationship, which is a link between glossary terms, where one describes the context where the other one is valid to use.
`SubjectAreaOMASAPIResponse`	`getValidValue(String serverName, String userId, String guid)` Get a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
`SubjectAreaOMASAPIResponse`	`restoreAntonym(String serverName, String userId, String guid)` Restore a Antonym
`SubjectAreaOMASAPIResponse`	`restoreCategoryAnchor(String serverName, String userId, String guid)` Restore a CategoryAnchor Relationship.
`SubjectAreaOMASAPIResponse`	`restoreIsa(String serverName, String userId, String guid)` Restore ISA Relationship
`SubjectAreaOMASAPIResponse`	`restorePreferredTerm(String serverName, String userId, String guid)` Restore a PreferredTerm
`SubjectAreaOMASAPIResponse`	`restoreProjectScoper(String serverName, String userId, String guid)` Restore a ProjectScope, which is a link between the project content and the project.
`SubjectAreaOMASAPIResponse`	`restoreRelatedTerm(String serverName, String userId, String guid)` Restore a related Term relationship.
`SubjectAreaOMASAPIResponse`	`restoreReplacementTerm(String serverName, String userId, String guid)` Restore a ReplacementTerm
`SubjectAreaOMASAPIResponse`	`restoreSynonym(String serverName, String userId, String guid)` Restore a Synonym
`SubjectAreaOMASAPIResponse`	`restoreTermAnchor(String serverName, String userId, String guid)` Restore a TermAnchor Relationship.
`SubjectAreaOMASAPIResponse`	`restoreTermCategorization(String serverName, String userId, String guid)` Restore a TermCategorization Relationship.
`SubjectAreaOMASAPIResponse`	`restoreTermHASA(String serverName, String userId, String guid)` Restore a has a relationship.
`SubjectAreaOMASAPIResponse`	`restoreTermIsaTypeOf(String serverName, String userId, String guid)` Restore a Is a Type Of Relationship
`SubjectAreaOMASAPIResponse`	`restoreTermTYPEDBY(String serverName, String userId, String guid)` Restore a Term TYPED BY relationship
`SubjectAreaOMASAPIResponse`	`restoreTranslation(String serverName, String userId, String guid)` Restore a Translation
`SubjectAreaOMASAPIResponse`	`restoreUsedInContext(String serverName, String userId, String guid)` Restore a UsedInContext
`SubjectAreaOMASAPIResponse`	`restoreValidValue(String serverName, String userId, String guid)` Restore a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
`SubjectAreaOMASAPIResponse`	`updateAntonym(String serverName, String userId, Antonym antonym, Boolean isReplace)` Update a Antonym relationship which is a link between glossary terms that have the opposite meaning
`SubjectAreaOMASAPIResponse`	`updateISA(String serverName, String userId, ISARelationship isa, Boolean isReplace)` Update a ISA relationship, which is a link between a more general glossary term and a more specific definition.
`SubjectAreaOMASAPIResponse`	`updateISA(String serverName, String userId, TermISATypeOFRelationship isatypeof, Boolean isReplace)` Update a ISARelationship relationship, which is a link between a more general glossary term and a more specific definition.
`SubjectAreaOMASAPIResponse`	`updatePreferredTerm(String serverName, String userId, PreferredTerm preferredTerm, Boolean isReplace)` Update a PreferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.
`SubjectAreaOMASAPIResponse`	`updateProjectScope(String serverName, String userId, ProjectScopeRelationship projectScope, Boolean isReplace)` Update a Project scope relationship which is a link between the project content and the project.
`SubjectAreaOMASAPIResponse`	`updateRelatedTerm(String serverName, String userId, RelatedTerm relatedTermRelationship, Boolean isReplace)` Update a Related Term relationship.
`SubjectAreaOMASAPIResponse`	`updateReplacementTerm(String serverName, String userId, ReplacementTerm replacementTerm, Boolean isReplace)` Update a ReplacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.
`SubjectAreaOMASAPIResponse`	`updateSynonym(String serverName, String userId, Synonym synonym, Boolean isReplace)` Update a Synonym relationship which is a link between glossary terms that have the same meaning
`SubjectAreaOMASAPIResponse`	`updateTermCategorization(String serverName, String userId, TermCategorizationRelationship isatypeof, Boolean isReplace)` Update a termCategorization Relationship.
`SubjectAreaOMASAPIResponse`	`updateTermHASA(String serverName, String userId, TermHASARelationship termHASARelationship, Boolean isReplace)` Update a TermHASARelationship is the relationship between a spine object and a spine attribute.
`SubjectAreaOMASAPIResponse`	`updateTermTYPEDBY(String serverName, String userId, TermTYPEDBYRelationship termTYPEDBYRelationship, Boolean isReplace)` Update a TermTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.
`SubjectAreaOMASAPIResponse`	`updateTranslation(String serverName, String userId, Translation translation, Boolean isReplace)` Update a Translation relationship translation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.
`SubjectAreaOMASAPIResponse`	`updateUsedInContext(String serverName, String userId, UsedInContext usedInContext, Boolean isReplace)` Update a UsedInContext relationship which is a link between glossary terms, where one describes the context where the other one is valid to use.
`SubjectAreaOMASAPIResponse`	`updateValidValue(String serverName, String userId, ValidValue validValue, Boolean isReplace)` Update a ValidValue relationship which is a link between glossary terms that have the same meaning

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

- Constructor Detail
  - GlossaryAuthorViewRelationshipRESTResource
```
public GlossaryAuthorViewRelationshipRESTResource()
```
    Default constructor
- Method Detail
  - createTermHASA
```
@PostMapping(path="/has-as")
public SubjectAreaOMASAPIResponse createTermHASA(@PathVariable
                                                                              String serverName,
                                                                              @PathVariable
                                                                              String userId,
                                                                              @RequestBody
                                                                              TermHASARelationship termHASARelationship)
```
    Create a TermHASARelationship is the 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. This allows the user to create terms then make them spine objects and spine attributes at a later stage.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termHASARelationship - the HASA relationship
    
    Returns:
    response, when successful contains the created TermHASARelationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - getTermHASA
```
@GetMapping(path="/has-as/{guid}")
public SubjectAreaOMASAPIResponse getTermHASA(@PathVariable
                                                                                 String serverName,
                                                                                 @PathVariable
                                                                                 String userId,
                                                                                 @PathVariable
                                                                                 String guid)
```
    Get a Term HAS A relationship
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the HAS A relationship to get
    
    Returns:
    response which when successful contains the term has a relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - updateTermHASA
```
@PutMapping(path="/has-as")
public SubjectAreaOMASAPIResponse updateTermHASA(@PathVariable
                                                                             String serverName,
                                                                             @PathVariable
                                                                             String userId,
                                                                             @RequestBody
                                                                             TermHASARelationship termHASARelationship,
                                                                             @RequestParam(value="isReplace",required=false)
                                                                             Boolean isReplace)
```
    Update a TermHASARelationship is the relationship between a spine object and a spine attribute.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termHASARelationship - the HASA relationship
    
    isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.
    
    Returns:
    response, when successful contains the created TermHASARelationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - deleteTermHASA
```
@DeleteMapping(path="/has-as/{guid}")
public SubjectAreaOMASAPIResponse deleteTermHASA(@PathVariable
                                                                                       String serverName,
                                                                                       @PathVariable
                                                                                       String userId,
                                                                                       @PathVariable
                                                                                       String guid,
                                                                                       @RequestParam(value="isPurge",required=false)
                                                                                       Boolean isPurge)
```
    Delete a Term HAS A relationship
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the HAS A relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the term has a relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restoreTermHASA
```
@PostMapping(path="/has-as/{guid}")
public SubjectAreaOMASAPIResponse restoreTermHASA(@PathVariable
                                                                                      String serverName,
                                                                                      @PathVariable
                                                                                      String userId,
                                                                                      @PathVariable
                                                                                      String guid)
```
    Restore a has a relationship.
    Restore allows the deleted relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the relationship to restore
    
    Returns:
    response which when successful contains the restored relationship when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - createRelatedTerm
```
@PostMapping(path="/related-terms")
public SubjectAreaOMASAPIResponse createRelatedTerm(@PathVariable
                                                                                        String serverName,
                                                                                        @PathVariable
                                                                                        String userId,
                                                                                        @RequestBody
                                                                                        RelatedTerm relatedTermRelationshipRelationship)
```
    Create a RelatedTerm. A Related Term is a link between two similar Terms.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    relatedTermRelationshipRelationship - the RelatedTerm relationship
    
    Returns:
    response, when successful contains the created Related Term relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - getRelatedTerm
```
@GetMapping(path="/related-terms/{guid}")
public SubjectAreaOMASAPIResponse getRelatedTerm(@PathVariable
                                                                                           String serverName,
                                                                                           @PathVariable
                                                                                           String userId,
                                                                                           @PathVariable
                                                                                           String guid)
```
    Get a related Term relationship.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the related term relationship to get
    
    Returns:
    response which when successful contains the related term relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - updateRelatedTerm
```
@PutMapping(path="/related-terms")
public SubjectAreaOMASAPIResponse updateRelatedTerm(@PathVariable
                                                                                       String serverName,
                                                                                       @PathVariable
                                                                                       String userId,
                                                                                       @RequestBody
                                                                                       RelatedTerm relatedTermRelationship,
                                                                                       @RequestParam(value="isReplace",required=false)
                                                                                       Boolean isReplace)
```
    Update a Related Term relationship. A Related Term is a link between two similar Terms.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    relatedTermRelationship - the related term relationship
    
    isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.
    
    Returns:
    response, when successful contains the created RelatedTerm when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - deleteRelatedTerm
```
@DeleteMapping(path="/related-terms/{guid}")
public SubjectAreaOMASAPIResponse deleteRelatedTerm(@PathVariable
                                                                                                 String serverName,
                                                                                                 @PathVariable
                                                                                                 String userId,
                                                                                                 @PathVariable
                                                                                                 String guid,
                                                                                                 @RequestParam(value="isPurge",required=false)
                                                                                                 Boolean isPurge)
```
    Delete a Related Term relationship
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Related term relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the related term relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restoreRelatedTerm
```
@PostMapping(path="/related-terms/{guid}")
public SubjectAreaOMASAPIResponse restoreRelatedTerm(@PathVariable
                                                                                                String serverName,
                                                                                                @PathVariable
                                                                                                String userId,
                                                                                                @PathVariable
                                                                                                String guid)
```
    Restore a related Term relationship.
    Restore allows the deleted relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the relationship to restore
    
    Returns:
    response which when successful contains the restored relationship when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - createSynonym
```
@PostMapping(path="/synonyms")
public SubjectAreaOMASAPIResponse createSynonym(@PathVariable
                                                                               String serverName,
                                                                               @PathVariable
                                                                               String userId,
                                                                               @RequestBody
                                                                               Synonym synonym)
```
    Create a synonym relationship, which is a link between glossary terms that have the same meaning.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    synonym - the Synonym relationship
    
    Returns:
    response, when successful contains the created synonym relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - getSynonym
```
@GetMapping(path="/synonyms/{guid}")
public SubjectAreaOMASAPIResponse getSynonym(@PathVariable
                                                                                  String serverName,
                                                                                  @PathVariable
                                                                                  String userId,
                                                                                  @PathVariable
                                                                                  String guid)
```
    Get a synonym relationship, which is a link between glossary terms that have the same meaning.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the synonym relationship to get
    
    Returns:
    response which when successful contains the synonym relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - updateSynonym
```
@PutMapping(path="/synonyms")
public SubjectAreaOMASAPIResponse updateSynonym(@PathVariable
                                                                              String serverName,
                                                                              @PathVariable
                                                                              String userId,
                                                                              @RequestBody
                                                                              Synonym synonym,
                                                                              @RequestParam(value="isReplace",required=false)
                                                                              Boolean isReplace)
```
    Update a Synonym relationship which is a link between glossary terms that have the same meaning
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    synonym - the synonym relationship
    
    isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.
    
    Returns:
    response, when successful contains the created SynonymRelationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - deleteSynonym
```
@DeleteMapping(path="/synonyms/{guid}")
public SubjectAreaOMASAPIResponse deleteSynonym(@PathVariable
                                                                                        String serverName,
                                                                                        @PathVariable
                                                                                        String userId,
                                                                                        @PathVariable
                                                                                        String guid,
                                                                                        @RequestParam(value="isPurge",required=false)
                                                                                        Boolean isPurge)
```
    Delete a Synonym relationship
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Synonym relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the Synonym relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restoreSynonym
```
@PostMapping(path="/synonyms/{guid}")
public SubjectAreaOMASAPIResponse restoreSynonym(@PathVariable
                                                                                       String serverName,
                                                                                       @PathVariable
                                                                                       String userId,
                                                                                       @PathVariable
                                                                                       String guid)
```
    Restore a Synonym
    Restore allows the deleted Synonym to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Synonym to delete
    
    Returns:
    response which when successful contains the restored Synonym when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
  - createAntonym
```
@PostMapping(path="/antonyms")
public SubjectAreaOMASAPIResponse createAntonym(@PathVariable
                                                                               String serverName,
                                                                               @PathVariable
                                                                               String userId,
                                                                               @RequestBody
                                                                               Antonym antonym)
```
    Create an antonym relationship, which is a link between glossary terms that have the opposite meaning.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    antonym - the Antonym relationship
    
    Returns:
    response, when successful contains the created antonym relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - getAntonym
```
@GetMapping(path="/antonyms/{guid}")
public SubjectAreaOMASAPIResponse getAntonym(@PathVariable
                                                                                  String serverName,
                                                                                  @PathVariable
                                                                                  String userId,
                                                                                  @PathVariable
                                                                                  String guid)
```
    Get a antonym relationship
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the related term relationship to get
    
    Returns:
    response which when successful contains the antonym relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - updateAntonym
```
@PutMapping(path="/antonyms")
public SubjectAreaOMASAPIResponse updateAntonym(@PathVariable
                                                                              String serverName,
                                                                              @PathVariable
                                                                              String userId,
                                                                              @RequestBody
                                                                              Antonym antonym,
                                                                              @RequestParam(value="isReplace",required=false)
                                                                              Boolean isReplace)
```
    Update a Antonym relationship which is a link between glossary terms that have the opposite meaning
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    antonym - the antonym relationship
    
    isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.
    
    Returns:
    response, when successful contains the created AntonymRelationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - deleteAntonym
```
@DeleteMapping(path="/antonyms/{guid}")
public SubjectAreaOMASAPIResponse deleteAntonym(@PathVariable
                                                                                        String serverName,
                                                                                        @PathVariable
                                                                                        String userId,
                                                                                        @PathVariable
                                                                                        String guid,
                                                                                        @RequestParam(value="isPurge",required=false)
                                                                                        Boolean isPurge)
```
    Delete a Antonym relationship
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Antonym relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the Antonym relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restoreAntonym
```
@PostMapping(path="/antonyms/{guid}")
public SubjectAreaOMASAPIResponse restoreAntonym(@PathVariable
                                                                                       String serverName,
                                                                                       @PathVariable
                                                                                       String userId,
                                                                                       @PathVariable
                                                                                       String guid)
```
    Restore a Antonym
    Restore allows the deleted Antonym to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Antonym to delete
    
    Returns:
    response which when successful contains the restored Antonym when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
  - createTranslation
```
@PostMapping(path="/translations")
public SubjectAreaOMASAPIResponse createTranslation(@PathVariable
                                                                                       String serverName,
                                                                                       @PathVariable
                                                                                       String userId,
                                                                                       @RequestBody
                                                                                       Translation translation)
```
    Create a translation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    translation - the Translation relationship
    
    Returns:
    response, when successful contains the created translation relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - getTranslation
```
@GetMapping(path="/translations/{guid}")
public SubjectAreaOMASAPIResponse getTranslation(@PathVariable
                                                                                          String serverName,
                                                                                          @PathVariable
                                                                                          String userId,
                                                                                          @PathVariable
                                                                                          String guid)
```
    Get a translation relationshiptranslation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the translation relationship to get
    
    Returns:
    response which when successful contains the translation relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - updateTranslation
```
@PutMapping(path="/translations")
public SubjectAreaOMASAPIResponse updateTranslation(@PathVariable
                                                                                      String serverName,
                                                                                      @PathVariable
                                                                                      String userId,
                                                                                      @RequestBody
                                                                                      Translation translation,
                                                                                      @RequestParam(value="isReplace",required=false)
                                                                                      Boolean isReplace)
```
    Update a Translation relationship translation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    translation - the translation relationship
    
    isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.
    
    Returns:
    response, when successful contains the created TranslationRelationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - deleteTranslation
```
@DeleteMapping(path="/translations/{guid}")
public SubjectAreaOMASAPIResponse deleteTranslation(@PathVariable
                                                                                                String serverName,
                                                                                                @PathVariable
                                                                                                String userId,
                                                                                                @PathVariable
                                                                                                String guid,
                                                                                                @RequestParam(value="isPurge",required=false)
                                                                                                Boolean isPurge)
```
    Delete a Translation relationshiptranslation relationship, which is a link between glossary terms to provide different natural language translation of the same concept.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Translation relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the Translation relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restoreTranslation
```
@PostMapping(path="/translations/{guid}")
public SubjectAreaOMASAPIResponse restoreTranslation(@PathVariable
                                                                                               String serverName,
                                                                                               @PathVariable
                                                                                               String userId,
                                                                                               @PathVariable
                                                                                               String guid)
```
    Restore a Translation
    Restore allows the deleted Translation to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Translation to delete
    
    Returns:
    response which when successful contains the restored Translation when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
  - createusedInContext
```
@PostMapping(path="/used-in-contexts")
public SubjectAreaOMASAPIResponse createusedInContext(@PathVariable
                                                                                             String serverName,
                                                                                             @PathVariable
                                                                                             String userId,
                                                                                             @RequestBody
                                                                                             UsedInContext usedInContext)
```
    Create a usedInContext relationship, which is a link between glossary terms, where one describes the context where the other one is valid to use.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    usedInContext - the UsedInContext relationship
    
    Returns:
    response, when successful contains the created usedInContext relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - getUsedInContext
```
@GetMapping(path="/used-in-contexts/{guid}")
public SubjectAreaOMASAPIResponse getUsedInContext(@PathVariable
                                                                                                String serverName,
                                                                                                @PathVariable
                                                                                                String userId,
                                                                                                @PathVariable
                                                                                                String guid)
```
    Get a usedInContext relationship, which is a link between glossary terms, where one describes the context where the other one is valid to use.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the usedInContext relationship to get
    
    Returns:
    response which when successful contains the usedInContext relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - updateUsedInContext
```
@PutMapping(path="/used-in-contexts")
public SubjectAreaOMASAPIResponse updateUsedInContext(@PathVariable
                                                                                            String serverName,
                                                                                            @PathVariable
                                                                                            String userId,
                                                                                            @RequestBody
                                                                                            UsedInContext usedInContext,
                                                                                            @RequestParam(value="isReplace",required=false)
                                                                                            Boolean isReplace)
```
    Update a UsedInContext relationship which is a link between glossary terms, where one describes the context where the other one is valid to use.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    usedInContext - the used in context relationship
    
    isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.
    
    Returns:
    response, when successful contains the created UsedInContextRelationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - deleteUsedInContext
```
@DeleteMapping(path="/used-in-contexts/{guid}")
public SubjectAreaOMASAPIResponse deleteUsedInContext(@PathVariable
                                                                                                      String serverName,
                                                                                                      @PathVariable
                                                                                                      String userId,
                                                                                                      @PathVariable
                                                                                                      String guid,
                                                                                                      @RequestParam(value="isPurge",required=false)
                                                                                                      Boolean isPurge)
```
    Delete a UsedInContext relationship which is a link between glossary terms, where one describes the context where the other one is valid to use.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the UsedInContext relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the UsedInContext relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restoreUsedInContext
```
@PostMapping(path="/used-in-contexts/{guid}")
public SubjectAreaOMASAPIResponse restoreUsedInContext(@PathVariable
                                                                                                     String serverName,
                                                                                                     @PathVariable
                                                                                                     String userId,
                                                                                                     @PathVariable
                                                                                                     String guid)
```
    Restore a UsedInContext
    Restore allows the deleted UsedInContext to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the UsedInContext to delete
    
    Returns:
    response which when successful contains the restored UsedInContext when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
  - createpreferredTerm
```
@PostMapping(path="/preferred-terms")
public SubjectAreaOMASAPIResponse createpreferredTerm(@PathVariable
                                                                                            String serverName,
                                                                                            @PathVariable
                                                                                            String userId,
                                                                                            @RequestBody
                                                                                            PreferredTerm preferredTerm)
```
    Create a preferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    preferredTerm - the preferred term relationship
    
    Returns:
    response, when successful contains the created preferredTerm relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - getPreferredTerm
```
@GetMapping(path="/preferred-terms/{guid}")
public SubjectAreaOMASAPIResponse getPreferredTerm(@PathVariable
                                                                                               String serverName,
                                                                                               @PathVariable
                                                                                               String userId,
                                                                                               @PathVariable
                                                                                               String guid)
```
    Get a preferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the preferredTerm relationship to get
    
    Returns:
    response which when successful contains the preferredTerm relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - updatePreferredTerm
```
@PutMapping(path="/preferred-terms")
public SubjectAreaOMASAPIResponse updatePreferredTerm(@PathVariable
                                                                                           String serverName,
                                                                                           @PathVariable
                                                                                           String userId,
                                                                                           @RequestBody
                                                                                           PreferredTerm preferredTerm,
                                                                                           @RequestParam(value="isReplace",required=false)
                                                                                           Boolean isReplace)
```
    Update a PreferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    preferredTerm - the preferred term relationship
    
    isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.
    
    Returns:
    response, when successful contains the created PreferredTermRelationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    FunctionNotSupportedException Function not supported
    StatusNotSupportedException A status value is not supported
  - deletePreferredTerm
```
@DeleteMapping(path="/preferred-terms/{guid}")
public SubjectAreaOMASAPIResponse deletePreferredTerm(@PathVariable
                                                                                                     String serverName,
                                                                                                     @PathVariable
                                                                                                     String userId,
                                                                                                     @PathVariable
                                                                                                     String guid,
                                                                                                     @RequestParam(value="isPurge",required=false)
                                                                                                     Boolean isPurge)
```
    Delete a PreferredTerm relationship, which is a link between glossary terms, it is a Link to an alternative term that the organization prefers is used.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the PreferredTerm relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the PreferredTerm relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restorePreferredTerm
```
@PostMapping(path="/preferred-terms/{guid}")
public SubjectAreaOMASAPIResponse restorePreferredTerm(@PathVariable
                                                                                                    String serverName,
                                                                                                    @PathVariable
                                                                                                    String userId,
                                                                                                    @PathVariable
                                                                                                    String guid)
```
    Restore a PreferredTerm
    Restore allows the deleted PreferredTerm to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the PreferredTerm to delete
    
    Returns:
    response which when successful contains the restored PreferredTerm when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
  - createvalidValue
```
@PostMapping(path="/valid-values")
public SubjectAreaOMASAPIResponse createvalidValue(@PathVariable
                                                                                      String serverName,
                                                                                      @PathVariable
                                                                                      String userId,
                                                                                      @RequestBody
                                                                                      ValidValue validValue)
```
    Create a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    validValue - the ValidValue relationship
    
    Returns:
    response, when successful contains the created validValue relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - getValidValue
```
@GetMapping(path="/valid-values/{guid}")
public SubjectAreaOMASAPIResponse getValidValue(@PathVariable
                                                                                         String serverName,
                                                                                         @PathVariable
                                                                                         String userId,
                                                                                         @PathVariable
                                                                                         String guid)
```
    Get a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the validValue relationship to get
    
    Returns:
    response which when successful contains the validValue relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - updateValidValue
```
@PutMapping(path="/valid-values")
public SubjectAreaOMASAPIResponse updateValidValue(@PathVariable
                                                                                     String serverName,
                                                                                     @PathVariable
                                                                                     String userId,
                                                                                     @RequestBody
                                                                                     ValidValue validValue,
                                                                                     @RequestParam(value="isReplace",required=false)
                                                                                     Boolean isReplace)
```
    Update a ValidValue relationship which is a link between glossary terms that have the same meaning
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    validValue - the valid value relationship
    
    isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.
    
    Returns:
    response, when successful contains the created ValidValueRelationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - deleteValidValue
```
@DeleteMapping(path="/valid-values/{guid}")
public SubjectAreaOMASAPIResponse deleteValidValue(@PathVariable
                                                                                               String serverName,
                                                                                               @PathVariable
                                                                                               String userId,
                                                                                               @PathVariable
                                                                                               String guid,
                                                                                               @RequestParam(value="isPurge",required=false)
                                                                                               Boolean isPurge)
```
    Delete a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ValidValue relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the ValidValue relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restoreValidValue
```
@PostMapping(path="/valid-values/{guid}")
public SubjectAreaOMASAPIResponse restoreValidValue(@PathVariable
                                                                                              String serverName,
                                                                                              @PathVariable
                                                                                              String userId,
                                                                                              @PathVariable
                                                                                              String guid)
```
    Restore a ValidValue relationship, which is link between glossary terms where one defines one of the data values for the another.
    Restore allows the deleted ValidValue to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ValidValue to delete
    
    Returns:
    response which when successful contains the restored ValidValue when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
  - createreplacementTerm
```
@PostMapping(path="/replacement-terms")
public SubjectAreaOMASAPIResponse createreplacementTerm(@PathVariable
                                                                                                String serverName,
                                                                                                @PathVariable
                                                                                                String userId,
                                                                                                @RequestBody
                                                                                                ReplacementTerm replacementTerm)
```
    Create a replacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    replacementTerm - the ReplacementTerm relationship
    
    Returns:
    response, when successful contains the created replacementTerm relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - getReplacementTerm
```
@GetMapping(path="/replacement-terms/{guid}")
public SubjectAreaOMASAPIResponse getReplacementTerm(@PathVariable
                                                                                                   String serverName,
                                                                                                   @PathVariable
                                                                                                   String userId,
                                                                                                   @PathVariable
                                                                                                   String guid)
```
    Get a replacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the replacementTerm relationship to get
    
    Returns:
    response which when successful contains the replacementTerm relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - updateReplacementTerm
```
@PutMapping(path="/replacement-terms")
public SubjectAreaOMASAPIResponse updateReplacementTerm(@PathVariable
                                                                                               String serverName,
                                                                                               @PathVariable
                                                                                               String userId,
                                                                                               @RequestBody
                                                                                               ReplacementTerm replacementTerm,
                                                                                               @RequestParam(value="isReplace",required=false)
                                                                                               Boolean isReplace)
```
    Update a ReplacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    replacementTerm - the replacement term relationship
    
    isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.
    
    Returns:
    response, when successful contains the created ReplacementTermRelationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - deleteReplacementTerm
```
@DeleteMapping(path="/replacement-terms/{guid}")
public SubjectAreaOMASAPIResponse deleteReplacementTerm(@PathVariable
                                                                                                         String serverName,
                                                                                                         @PathVariable
                                                                                                         String userId,
                                                                                                         @PathVariable
                                                                                                         String guid,
                                                                                                         @RequestParam(value="isPurge",required=false)
                                                                                                         Boolean isPurge)
```
    Delete a ReplacementTerm relationship, which is a link to a glossary term that is replacing an obsolete glossary term.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ReplacementTerm relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the ReplacementTerm relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restoreReplacementTerm
```
@PostMapping(path="/replacement-terms/{guid}")
public SubjectAreaOMASAPIResponse restoreReplacementTerm(@PathVariable
                                                                                                        String serverName,
                                                                                                        @PathVariable
                                                                                                        String userId,
                                                                                                        @PathVariable
                                                                                                        String guid)
```
    Restore a ReplacementTerm
    Restore allows the deleted ReplacementTerm to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ReplacementTerm to delete
    
    Returns:
    response which when successful contains the restored ReplacementTerm when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
  - createtermTYPEDBY
```
@PostMapping(path="/typed-bys")
public SubjectAreaOMASAPIResponse createtermTYPEDBY(@PathVariable
                                                                                    String serverName,
                                                                                    @PathVariable
                                                                                    String userId,
                                                                                    @RequestBody
                                                                                    TermTYPEDBYRelationship termTYPEDBYRelationship)
```
    Create a termTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termTYPEDBYRelationship - the TermTYPEDBYRelationship relationship
    
    Returns:
    response, when successful contains the created termTYPEDBYRelationship relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - getTYPEDBY
```
@GetMapping(path="/typed-bys/{guid}")
public SubjectAreaOMASAPIResponse getTYPEDBY(@PathVariable
                                                                                   String serverName,
                                                                                   @PathVariable
                                                                                   String userId,
                                                                                   @PathVariable
                                                                                   String guid)
```
    Get a termTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the termTYPEDBYRelationship relationship to get
    
    Returns:
    response which when successful contains the termTYPEDBYRelationship relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - updateTermTYPEDBY
```
@PutMapping(path="/typed-bys")
public SubjectAreaOMASAPIResponse updateTermTYPEDBY(@PathVariable
                                                                                   String serverName,
                                                                                   @PathVariable
                                                                                   String userId,
                                                                                   @RequestBody
                                                                                   TermTYPEDBYRelationship termTYPEDBYRelationship,
                                                                                   @RequestParam(value="isReplace",required=false)
                                                                                   Boolean isReplace)
```
    Update a TermTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termTYPEDBYRelationship - the typed by relationship
    
    isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.
    
    Returns:
    response, when successful contains the created TermTYPEDBYRelationshipRelationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - deleteTypedBy
```
@DeleteMapping(path="/typed-bys/{guid}")
public SubjectAreaOMASAPIResponse deleteTypedBy(@PathVariable
                                                                                         String serverName,
                                                                                         @PathVariable
                                                                                         String userId,
                                                                                         @PathVariable
                                                                                         String guid,
                                                                                         @RequestParam(value="isPurge",required=false)
                                                                                         Boolean isPurge)
```
    Delete a TermTYPEDBYRelationship relationship, which is a link between a spine attribute and its type.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermTYPEDBYRelationship relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the TermTYPEDBYRelationship relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restoreTermTYPEDBY
```
@PostMapping(path="/typed-bys/{guid}")
public SubjectAreaOMASAPIResponse restoreTermTYPEDBY(@PathVariable
                                                                                            String serverName,
                                                                                            @PathVariable
                                                                                            String userId,
                                                                                            @PathVariable
                                                                                            String guid)
```
    Restore a Term TYPED BY relationship
    Restore allows the deleted TermTYPEDBY to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermTYPEDBY to delete
    
    Returns:
    response which when successful contains the restored TermTYPEDBY when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
  - createiSA
```
@PostMapping(path="/is-as")
public SubjectAreaOMASAPIResponse createiSA(@PathVariable
                                                                        String serverName,
                                                                        @PathVariable
                                                                        String userId,
                                                                        @RequestBody
                                                                        ISARelationship iSARelationship)
```
    Create a iSARelationship relationship, which is a link between a more general glossary term and a more specific definition.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    iSARelationship - the ISARelationship relationship
    
    Returns:
    response, when successful contains the created iSARelationship relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - getISA
```
@GetMapping(path="/is-as/{guid}")
public SubjectAreaOMASAPIResponse getISA(@PathVariable
                                                                           String serverName,
                                                                           @PathVariable
                                                                           String userId,
                                                                           @PathVariable
                                                                           String guid)
```
    Get a ISA relationship, which is a link between a more general glossary term and a more specific definition.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the iSARelationship relationship to get
    
    Returns:
    response which when successful contains the iSARelationship relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - updateISA
```
@PutMapping(path="/is-as")
public SubjectAreaOMASAPIResponse updateISA(@PathVariable
                                                                       String serverName,
                                                                       @PathVariable
                                                                       String userId,
                                                                       @RequestBody
                                                                       ISARelationship isa,
                                                                       @RequestParam(value="isReplace",required=false)
                                                                       Boolean isReplace)
```
    Update a ISA relationship, which is a link between a more general glossary term and a more specific definition.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    isa - the is-a relationship
    
    isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.
    
    Returns:
    response, when successful contains the created ISARelationshipRelationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - deleteTermISA
```
@DeleteMapping(path="/is-as/{guid}")
public SubjectAreaOMASAPIResponse deleteTermISA(@PathVariable
                                                                                     String serverName,
                                                                                     @PathVariable
                                                                                     String userId,
                                                                                     @PathVariable
                                                                                     String guid,
                                                                                     @RequestParam(value="isPurge",required=false)
                                                                                     Boolean isPurge)
```
    Delete a ISA relationship, which is a link between a more general glossary term and a more specific definition.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ISARelationship relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the ISARelationship relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restoreIsa
```
@PostMapping(path="/is-as/{guid}")
public SubjectAreaOMASAPIResponse restoreIsa(@PathVariable
                                                                                String serverName,
                                                                                @PathVariable
                                                                                String userId,
                                                                                @PathVariable
                                                                                String guid)
```
    Restore ISA Relationship
    Restore allows the deleted ISA Relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Isa Relationship to delete
    
    Returns:
    response which when successful contains the restored IsaRelationship when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
  - createtermISATypeOF
```
@PostMapping(path="/is-a-type-ofs")
public SubjectAreaOMASAPIResponse createtermISATypeOF(@PathVariable
                                                                                          String serverName,
                                                                                          @PathVariable
                                                                                          String userId,
                                                                                          @RequestBody
                                                                                          TermISATypeOFRelationship termISATypeOFRelationship)
```
    Create a termISATypeOFRelationship relationship, which is an inheritance relationship between two spine objects.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termISATypeOFRelationship - the TermISATypeOFRelationship relationship
    
    Returns:
    response, when successful contains the created termISATypeOFRelationship relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - getTermISATypeOF
```
@GetMapping(path="/is-a-type-ofs/{guid}")
public SubjectAreaOMASAPIResponse getTermISATypeOF(@PathVariable
                                                                                             String serverName,
                                                                                             @PathVariable
                                                                                             String userId,
                                                                                             @PathVariable
                                                                                             String guid)
```
    Get a termISATypeOFRelationship relationship, which is an inheritance relationship between two spine objects.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the termISATypeOFRelationship relationship to get
    
    Returns:
    response which when successful contains the termISATypeOFRelationship relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - updateISA
```
@PutMapping(path="/is-a-type-ofs")
public SubjectAreaOMASAPIResponse updateISA(@PathVariable
                                                                               String serverName,
                                                                               @PathVariable
                                                                               String userId,
                                                                               @RequestBody
                                                                               TermISATypeOFRelationship isatypeof,
                                                                               @RequestParam(value="isReplace",required=false)
                                                                               Boolean isReplace)
```
    Update a ISARelationship relationship, which is a link between a more general glossary term and a more specific definition.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    isatypeof - the is-a-type-of relationship
    
    isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.
    
    Returns:
    response, when successful contains the created ISARelationshipRelationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - deleteTermIsaTypeOf
```
@DeleteMapping(path="/is-a-type-ofs/{guid}")
public SubjectAreaOMASAPIResponse deleteTermIsaTypeOf(@PathVariable
                                                                                                   String serverName,
                                                                                                   @PathVariable
                                                                                                   String userId,
                                                                                                   @PathVariable
                                                                                                   String guid,
                                                                                                   @RequestParam(value="isPurge",required=false)
                                                                                                   Boolean isPurge)
```
    Delete a TermISATypeOFRelationship relationship, which is an inheritance relationship between two spine objects.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermISATypeOFRelationship relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the TermISATypeOFRelationship relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restoreTermIsaTypeOf
```
@PostMapping(path="/is-a-type-ofs/{guid}")
public SubjectAreaOMASAPIResponse restoreTermIsaTypeOf(@PathVariable
                                                                                                  String serverName,
                                                                                                  @PathVariable
                                                                                                  String userId,
                                                                                                  @PathVariable
                                                                                                  String guid)
```
    Restore a Is a Type Of Relationship
    Restore allows the deleted Is a Type Of Relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Term Is a Type Of Relationship to delete
    
    Returns:
    response which when successful contains the restored TermIsaTypeOfRelationship when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
  - createTermCategorization
```
@PostMapping(path="/term-categorizations")
public SubjectAreaOMASAPIResponse createTermCategorization(@PathVariable
                                                                                                      String serverName,
                                                                                                      @PathVariable
                                                                                                      String userId,
                                                                                                      @RequestBody
                                                                                                      TermCategorizationRelationship termCategorizationRelationship)
```
    Create a termCategorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termCategorizationRelationship - the TermCategorizationRelationship relationship
    
    Returns:
    response, when successful contains the created termCategorizationRelationship relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - getTermCategorization
```
@GetMapping(path="/term-categorizations/{guid}")
public SubjectAreaOMASAPIResponse getTermCategorization(@PathVariable
                                                                                                         String serverName,
                                                                                                         @PathVariable
                                                                                                         String userId,
                                                                                                         @PathVariable
                                                                                                         String guid)
```
    Get a termCategorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the termCategorizationRelationship relationship to get
    
    Returns:
    response which when successful contains the termCategorizationRelationship relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - updateTermCategorization
```
@PutMapping(path="/term-categorizations")
public SubjectAreaOMASAPIResponse updateTermCategorization(@PathVariable
                                                                                                     String serverName,
                                                                                                     @PathVariable
                                                                                                     String userId,
                                                                                                     @RequestBody
                                                                                                     TermCategorizationRelationship isatypeof,
                                                                                                     @RequestParam(value="isReplace",required=false)
                                                                                                     Boolean isReplace)
```
    Update a termCategorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    isatypeof - the is-a-type-of relationship
    
    isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.
    
    Returns:
    response, when successful contains the created termCategorization Relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - deleteTermCategorization
```
@DeleteMapping(path="/term-categorizations/{guid}")
public SubjectAreaOMASAPIResponse deleteTermCategorization(@PathVariable
                                                                                                               String serverName,
                                                                                                               @PathVariable
                                                                                                               String userId,
                                                                                                               @PathVariable
                                                                                                               String guid,
                                                                                                               @RequestParam(value="isPurge",required=false)
                                                                                                               Boolean isPurge)
```
    Delete a TermCategorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermCategorizationRelationship relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the TermCategorizationRelationship relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restoreTermCategorization
```
@PostMapping(path="/term-categorizations/{guid}")
public SubjectAreaOMASAPIResponse restoreTermCategorization(@PathVariable
                                                                                                              String serverName,
                                                                                                              @PathVariable
                                                                                                              String userId,
                                                                                                              @PathVariable
                                                                                                              String guid)
```
    Restore a TermCategorization Relationship. A relationship between a Category and a Term. This relationship allows terms to be categorized.
    Restore allows the deleted TermCategorization Relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Term Is a Type Of Relationship to delete
    
    Returns:
    response which when successful contains the restored TermCategorization when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
  - createTermAnchor
```
@PostMapping(path="/term-anchor")
public SubjectAreaOMASAPIResponse createTermAnchor(@PathVariable
                                                                                     String serverName,
                                                                                     @PathVariable
                                                                                     String userId,
                                                                                     @RequestBody
                                                                                     TermAnchorRelationship termAnchorRelationship)
```
    Create a termAnchor Relationship. A relationship between a Glossary and a Term. This relationship allows terms to be owned by a Glossary. Terms created using the Glossary Author OMVS cannot be created without a glossary and there can only be one glossary associated with a Term. This method is to allow glossaries to be associated with Terms that have not been created via the Glossary Author OMVS or to recreate the TermAnchor relationship if it has been purged.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    termAnchorRelationship - the TermAnchorRelationship relationship
    
    Returns:
    response, when successful contains the created termAnchorRelationship relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    ClassificationException Error processing a classification.
    
    StatusNotSupportedException A status value is not supported.
    
    FunctionNotSupportedException Function not supported.
  - getTermAnchor
```
@GetMapping(path="/term-anchor/{guid}")
public SubjectAreaOMASAPIResponse getTermAnchor(@PathVariable
                                                                                        String serverName,
                                                                                        @PathVariable
                                                                                        String userId,
                                                                                        @PathVariable
                                                                                        String guid)
```
    Get a termAnchor Relationship. A relationship between a Glossary and a Term. This relationship allows terms to be owned by a Glossary.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the termAnchor Relationship to get
    
    Returns:
    response which when successful contains the termAnchorRelationship relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - deleteTermAnchor
```
@DeleteMapping(path="/term-anchor/{guid}")
public SubjectAreaOMASAPIResponse deleteTermAnchor(@PathVariable
                                                                                              String serverName,
                                                                                              @PathVariable
                                                                                              String userId,
                                                                                              @PathVariable
                                                                                              String guid,
                                                                                              @RequestParam(value="isPurge",required=false)
                                                                                              Boolean isPurge)
```
    Delete a TermAnchor Relationship. A relationship between a Glossary and a Term. This relationship allows terms to be owned by a Glossary.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the TermAnchorRelationship relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the TermAnchorRelationship relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restoreTermAnchor
```
@PostMapping(path="/term-anchor/{guid}")
public SubjectAreaOMASAPIResponse restoreTermAnchor(@PathVariable
                                                                                             String serverName,
                                                                                             @PathVariable
                                                                                             String userId,
                                                                                             @PathVariable
                                                                                             String guid)
```
    Restore a TermAnchor Relationship. A relationship between a Glossary and a Term. This relationship allows terms to be owned by a Glossary.
    Restore allows the deleted TermAnchor Relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Term Anchor Relationship to delete
    
    Returns:
    response which when successful contains the restored TermAnchor when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
  - createCategoryAnchor
```
@PostMapping(path="/category-anchor")
public SubjectAreaOMASAPIResponse createCategoryAnchor(@PathVariable
                                                                                             String serverName,
                                                                                             @PathVariable
                                                                                             String userId,
                                                                                             @RequestBody
                                                                                             CategoryAnchorRelationship categoryAnchorRelationship)
```
    Create a categoryAnchor Relationship. A relationship between a Glossary and a Category. This relationship allows categories to be owned by a Glossary. Categories created using the Subject Area OMAS cannot be created without a glossary and there can only be one glossary associated with a Category. This method is to allow glossaries to be associated with Categories that have not been created via the Glossary Author OMVS or to recreate the CategoryAnchor relationship if it has been purged.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    categoryAnchorRelationship - the CategoryAnchorRelationship relationship
    
    Returns:
    response, when successful contains the created categoryAnchorRelationship relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    ClassificationException Error processing a classification.
    
    StatusNotSupportedException A status value is not supported.
    
    FunctionNotSupportedException Function not supported.
  - getCategoryAnchor
```
@GetMapping(path="/category-anchor/{guid}")
public SubjectAreaOMASAPIResponse getCategoryAnchor(@PathVariable
                                                                                                String serverName,
                                                                                                @PathVariable
                                                                                                String userId,
                                                                                                @PathVariable
                                                                                                String guid)
```
    Get a categoryAnchor Relationship. A relationship between a Glossary and a Category. This relationship allows Categories to be owned by a Glossary.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the categoryAnchor Relationship to get
    
    Returns:
    response which when successful contains the categoryAnchorRelationship relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - deleteCategoryAnchor
```
@DeleteMapping(path="/category-anchor/{guid}")
public SubjectAreaOMASAPIResponse deleteCategoryAnchor(@PathVariable
                                                                                                      String serverName,
                                                                                                      @PathVariable
                                                                                                      String userId,
                                                                                                      @PathVariable
                                                                                                      String guid,
                                                                                                      @RequestParam(value="isPurge",required=false)
                                                                                                      Boolean isPurge)
```
    Delete a CategoryAnchor Relationship. A relationship between a Glossary and a Category. This relationship allows categories to be owned by a Glossary.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the CategoryAnchorRelationship relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the CategoryAnchorRelationship relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restoreCategoryAnchor
```
@PostMapping(path="/category-anchor/{guid}")
public SubjectAreaOMASAPIResponse restoreCategoryAnchor(@PathVariable
                                                                                                     String serverName,
                                                                                                     @PathVariable
                                                                                                     String userId,
                                                                                                     @PathVariable
                                                                                                     String guid)
```
    Restore a CategoryAnchor Relationship. A relationship between a Glossary and a Category. This relationship allows categories to be owned by a Glossary.
    Restore allows the deleted CategoryAnchor Relationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Category Anchor Relationship to delete
    
    Returns:
    response which when successful contains the restored CategoryAnchor when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
  - createProjectScope
```
@PostMapping(path="/project-scopes")
public SubjectAreaOMASAPIResponse createProjectScope(@PathVariable
                                                                                          String serverName,
                                                                                          @PathVariable
                                                                                          String userId,
                                                                                          @RequestBody
                                                                                          ProjectScopeRelationship projectScope)
```
    Create a project scope relationship, which is a link between the project content and the project.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    projectScope - the Project scope relationship
    
    Returns:
    response, when successful contains the created project scope relationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - getProjectScope
```
@GetMapping(path="/project-scopes/{guid}")
public SubjectAreaOMASAPIResponse getProjectScope(@PathVariable
                                                                                             String serverName,
                                                                                             @PathVariable
                                                                                             String userId,
                                                                                             @PathVariable
                                                                                             String guid)
```
    Get a project scope relationship, which is a link between the project content and the project.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the project scope relationship to get
    
    Returns:
    response which when successful contains the project scope relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised
  - updateProjectScope
```
@PutMapping(path="/project-scopes")
public SubjectAreaOMASAPIResponse updateProjectScope(@PathVariable
                                                                                         String serverName,
                                                                                         @PathVariable
                                                                                         String userId,
                                                                                         @RequestBody
                                                                                         ProjectScopeRelationship projectScope,
                                                                                         @RequestParam(value="isReplace",required=false)
                                                                                         Boolean isReplace)
```
    Update a Project scope relationship which is a link between the project content and the project.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - userId under which the request is performed
    
    projectScope - the projectScope relationship
    
    isReplace - flag to indicate that this update is a replace. When not set only the supplied (non null) fields are updated.
    
    Returns:
    response, when successful contains the created ProjectScopeRelationship when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    InvalidParameterException one of the parameters is null or invalid.
    UnrecognizedGUIDException the supplied guid was not recognised
    ClassificationException Error processing a classification
    StatusNotSupportedException A status value is not supported
  - deleteProjectScope
```
@DeleteMapping(path="/project-scopes/{guid}")
public SubjectAreaOMASAPIResponse deleteProjectScope(@PathVariable
                                                                                                   String serverName,
                                                                                                   @PathVariable
                                                                                                   String userId,
                                                                                                   @PathVariable
                                                                                                   String guid,
                                                                                                   @RequestParam(value="isPurge",required=false)
                                                                                                   Boolean isPurge)
```
    Delete a Project scope relationship which is a link between the project content and the project.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the Project scope relationship to delete
    
    isPurge - true indicates a hard delete, false is a soft delete.
    
    Returns:
    response which when successful contains the Project scope relationship with the requested guid when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
    
    EntityNotDeletedException a soft delete was issued but the relationship was not deleted.
    
    GUIDNotPurgedException a hard delete was issued but the relationship was not purged
  - restoreProjectScoper
```
@PostMapping(path="/project-scopes/{guid}")
public SubjectAreaOMASAPIResponse restoreProjectScoper(@PathVariable
                                                                                                   String serverName,
                                                                                                   @PathVariable
                                                                                                   String userId,
                                                                                                   @PathVariable
                                                                                                   String guid)
```
    Restore a ProjectScope, which is a link between the project content and the project.
    Restore allows the deleted ProjectScopeRelationship to be made active again. Restore allows deletes to be undone. Hard deletes are not stored in the repository so cannot be restored.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the ProjectScopeRelationship to delete
    
    Returns:
    response which when successful contains the restored ProjectScopeRelationship when not successful the following Exception responses can occur
    
    UnrecognizedGUIDException the supplied guid was not recognised
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    FunctionNotSupportedException Function not supported this indicates that a soft delete was issued but the repository does not support it.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service. There is a problem retrieving properties from the metadata repository.
  - getSemanticAssignment
```
@GetMapping(path="/semantic-assignments/{guid}")
public SubjectAreaOMASAPIResponse getSemanticAssignment(@PathVariable
                                                                                                         String serverName,
                                                                                                         @PathVariable
                                                                                                         String userId,
                                                                                                         @PathVariable
                                                                                                         String guid)
```
    Get a SemanticAssignment relationship, Links a glossary term to another element such as an asset or schema element to define its meaning.
    Parameters:
    
    serverName - serverName under which this request is performed, this is used in multi tenanting to identify the tenant
    
    userId - unique identifier for requesting user, under which the request is performed
    
    guid - guid of the SemanticAssignment relationship to get
    
    Returns:
    response which when successful contains the SemanticAssignment relationship with the requested guid when not successful the following Exception responses can occur
    
    UserNotAuthorizedException the requesting user is not authorized to issue this request.
    
    MetadataServerUncontactableException not able to communicate with a Metadata respository service.
    
    InvalidParameterException one of the parameters is null or invalid.
    
    UnrecognizedGUIDException the supplied guid was not recognised

Class GlossaryAuthorViewRelationshipRESTResource

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

GlossaryAuthorViewRelationshipRESTResource

Method Detail

createTermHASA

getTermHASA

updateTermHASA

deleteTermHASA

restoreTermHASA

createRelatedTerm

getRelatedTerm

updateRelatedTerm

deleteRelatedTerm

restoreRelatedTerm

createSynonym

getSynonym

updateSynonym

deleteSynonym

restoreSynonym

createAntonym

getAntonym

updateAntonym

deleteAntonym

restoreAntonym

createTranslation

getTranslation

updateTranslation

deleteTranslation

restoreTranslation

createusedInContext

getUsedInContext

updateUsedInContext

deleteUsedInContext

restoreUsedInContext

createpreferredTerm

getPreferredTerm

updatePreferredTerm

deletePreferredTerm

restorePreferredTerm

createvalidValue

getValidValue

updateValidValue

deleteValidValue

restoreValidValue

createreplacementTerm

getReplacementTerm

updateReplacementTerm

deleteReplacementTerm

restoreReplacementTerm

createtermTYPEDBY

getTYPEDBY

updateTermTYPEDBY

deleteTypedBy

restoreTermTYPEDBY

createiSA

getISA

updateISA

deleteTermISA

restoreIsa

createtermISATypeOF

getTermISATypeOF

updateISA

deleteTermIsaTypeOf

restoreTermIsaTypeOf

createTermCategorization

getTermCategorization

updateTermCategorization

deleteTermCategorization

restoreTermCategorization

createTermAnchor

getTermAnchor

deleteTermAnchor

restoreTermAnchor

createCategoryAnchor

getCategoryAnchor

deleteCategoryAnchor

restoreCategoryAnchor