java.lang.Object
- org.odpi.openmetadata.integrationservices.lineage.connector.LineageIntegratorContext

```
public class LineageIntegratorContext
extends Object
```
LineageIntegratorContext provides a wrapper around the Asset Manager OMAS client. It provides the simplified interface to open metadata needed by the LineageIntegratorConnector.

Constructor Summary

Constructors
Constructor	Description
`LineageIntegratorContext(DataAssetExchangeClient dataAssetExchangeClient, LineageExchangeClient lineageExchangeClient, String userId, String assetManagerGUID, String assetManagerName, String connectorName, String integrationServiceName, AuditLog auditLog)`	Create a new context for a connector.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`clearBusinessSignificant(String elementGUID)`	Remove the "BusinessSignificant" designation from the element.
`void`	`clearColumnAsPrimaryKey(String schemaAttributeGUID)`	Remove the primary key designation from the schema attribute.
`void`	`clearControlFlow(String controlFlowGUID)`	Remove the control flow relationship between two elements.
`void`	`clearDataAssetAsReferenceData(String assetGUID)`	Remove the reference data designation from the asset.
`void`	`clearDataFlow(String dataFlowGUID)`	Remove the data flow relationship between two elements.
`void`	`clearForeignKeyRelationship(String primaryKeyGUID, String foreignKeyGUID)`	Remove the foreign key relationship between two schema elements.
`void`	`clearLineageMapping(String sourceElementGUID, String destinationElementGUID)`	Remove the lineage mapping between two elements.
`void`	`clearPortDelegation(String portOneGUID, String portTwoGUID)`	Remove the port delegation relationship between two ports.
`void`	`clearPortSchemaType(String portGUID, String schemaTypeGUID)`	Remove the schema type from a port.
`void`	`clearProcessCall(String processCallGUID)`	Remove the process call relationship.
`void`	`clearProcessParent(String parentProcessGUID, String childProcessGUID)`	Remove a parent-child relationship between two processes.
`void`	`clearProcessPort(String processGUID, String portGUID)`	Unlink a port from a process.
`void`	`clearSchemaElementAsCalculatedValue(String schemaElementGUID)`	Remove the calculated value designation from the schema element.
`void`	`clearSchemaTypeParent(String schemaTypeGUID, String parentElementGUID, String parentElementTypeName)`	Remove the relationship between a schema type and its parent data asset, process or port.
`String`	`createDataAsset(boolean assetManagerIsHome, DataAssetProperties assetProperties)`	Create a new metadata element to represent the root of a data asset.
`String`	`createDataAssetFromTemplate(boolean assetManagerIsHome, String templateGUID, TemplateProperties templateProperties)`	Create a new metadata element to represent an asset using an existing metadata element as a template.
`String`	`createPort(boolean assetManagerIsHome, String processGUID, PortProperties portProperties)`	Create a new metadata element to represent a port.
`String`	`createProcess(boolean assetManagerIsHome, ProcessProperties processProperties, ProcessStatus initialStatus)`	Create a new metadata element to represent a process.
`String`	`createProcessFromTemplate(boolean assetManagerIsHome, String templateGUID, TemplateProperties templateProperties)`	Create a new metadata element to represent a process using an existing metadata element as a template.
`String`	`createSchemaAttribute(boolean assetManagerIsHome, String schemaElementGUID, SchemaAttributeProperties schemaAttributeProperties)`	Create a new metadata element to represent a schema attribute.
`String`	`createSchemaAttributeFromTemplate(boolean assetManagerIsHome, String schemaElementGUID, String templateGUID, TemplateProperties templateProperties)`	Create a new metadata element to represent a schema attribute using an existing metadata element as a template.
`String`	`createSchemaType(boolean assetManagerIsHome, String schemaTypeGUID, SchemaTypeProperties schemaTypeProperties)`	Create a new metadata element to represent a schema type.
`String`	`createSchemaTypeFromTemplate(boolean assetManagerIsHome, String templateGUID, TemplateProperties templateProperties)`	Create a new metadata element to represent a schema type using an existing metadata element as a template.
`List<DataAssetElement>`	`findDataAssets(String searchString, int startFrom, int pageSize)`	Retrieve the list of data asset metadata elements that contain the search string.
`List<PortElement>`	`findPorts(String searchString, int startFrom, int pageSize)`	Retrieve the list of port metadata elements that contain the search string.
`List<ProcessElement>`	`findProcesses(String searchString, int startFrom, int pageSize)`	Retrieve the list of process metadata elements that contain the search string.
`List<SchemaAttributeElement>`	`findSchemaAttributes(String searchString, int startFrom, int pageSize)`	Retrieve the list of schema attribute metadata elements that contain the search string.
`List<SchemaTypeElement>`	`findSchemaType(String searchString, int startFrom, int pageSize)`	Retrieve the list of schema type metadata elements that contain the search string.
`List<SchemaAttributeElement>`	`getAttributesForSchemaType(String schemaTypeGUID, int startFrom, int pageSize)`	Retrieve the list of schema attributes associated with a schemaType.
`ControlFlowElement`	`getControlFlow(String currentStepGUID, String nextStepGUID, String qualifiedName)`	Retrieve the control flow relationship between two elements.
`List<ControlFlowElement>`	`getControlFlowNextSteps(String currentStepGUID)`	Retrieve the control relationships linked from an specific element to the possible next elements in the process.
`List<ControlFlowElement>`	`getControlFlowPreviousSteps(String currentStepGUID)`	Retrieve the control relationships linked from an specific element to the possible previous elements in the process.
`DataAssetElement`	`getDataAssetByGUID(String openMetadataGUID)`	Retrieve the asset metadata element with the supplied unique identifier.
`List<DataAssetElement>`	`getDataAssetsByName(String name, int startFrom, int pageSize)`	Retrieve the list of data asset metadata elements with a matching qualified or display name.
`List<DataAssetElement>`	`getDataAssetsForAssetManager(int startFrom, int pageSize)`	Retrieve the list of assets created on behalf of this asset manager.
`DataFlowElement`	`getDataFlow(String dataSupplierGUID, String dataConsumerGUID, String qualifiedName)`	Retrieve the data flow relationship between two elements.
`List<DataFlowElement>`	`getDataFlowConsumers(String dataSupplierGUID)`	Retrieve the data flow relationships linked from an specific element to the downstream consumers.
`List<DataFlowElement>`	`getDataFlowSuppliers(String dataConsumerGUID)`	Retrieve the data flow relationships linked from an specific element to the upstream suppliers.
`PortElement`	`getPortByGUID(String portGUID)`	Retrieve the port metadata element with the supplied unique identifier.
`PortElement`	`getPortDelegation(String portGUID)`	Retrieve the port that this port delegates to.
`List<PortElement>`	`getPortsByName(String name, int startFrom, int pageSize)`	Retrieve the list of port metadata elements with a matching qualified or display name.
`List<PortElement>`	`getPortsForProcess(String processGUID, int startFrom, int pageSize)`	Retrieve the list of ports associated with a process.
`List<PortElement>`	`getPortUse(String portGUID, int startFrom, int pageSize)`	Retrieve the list of ports that delegate to this port.
`ProcessElement`	`getProcessByGUID(String processGUID)`	Retrieve the process metadata element with the supplied unique identifier.
`ProcessCallElement`	`getProcessCall(String callerGUID, String calledGUID, String qualifiedName)`	Retrieve the process call relationship between two elements.
`List<ProcessCallElement>`	`getProcessCalled(String callerGUID)`	Retrieve the process call relationships linked from an specific element to the elements it calls.
`List<ProcessCallElement>`	`getProcessCallers(String calledGUID)`	Retrieve the process call relationships linked from an specific element to its callers.
`List<ProcessElement>`	`getProcessesByName(String name, int startFrom, int pageSize)`	Retrieve the list of process metadata elements with a matching qualified or display name.
`List<ProcessElement>`	`getProcessesForAssetManager(int startFrom, int pageSize)`	Return the list of processes associated with the asset manager.
`ProcessElement`	`getProcessParent(String processGUID)`	Retrieve the process metadata element with the supplied unique identifier.
`SchemaAttributeElement`	`getSchemaAttributeByGUID(String schemaAttributeGUID)`	Retrieve the schema attribute metadata element with the supplied unique identifier.
`List<SchemaAttributeElement>`	`getSchemaAttributesByName(String name, int startFrom, int pageSize)`	Retrieve the list of schema attribute metadata elements with a matching qualified or display name.
`SchemaTypeElement`	`getSchemaTypeByGUID(String schemaTypeGUID)`	Retrieve the schema type metadata element with the supplied unique identifier.
`List<SchemaTypeElement>`	`getSchemaTypeByName(String name, int startFrom, int pageSize)`	Retrieve the list of schema type metadata elements with a matching qualified or display name.
`SchemaTypeElement`	`getSchemaTypeForElement(String parentElementGUID, String parentElementTypeName)`	Return the schema type associated with a specific open metadata element (data asset, process or port).
`ElementHeader`	`getSchemaTypeParent(String schemaTypeGUID)`	Retrieve the header of the metadata element connected to a schema type.
`List<ProcessElement>`	`getSubProcesses(String processGUID, int startFrom, int pageSize)`	Retrieve the process metadata element with the supplied unique identifier.
`void`	`publishDataAsset(String assetGUID)`	Update the zones for the data asset so that it becomes visible to consumers.
`void`	`publishProcess(String processGUID)`	Update the zones for the asset so that it becomes visible to consumers.
`void`	`removeDataAsset(String assetGUID)`	Remove the metadata element representing a data asset.
`void`	`removePort(String portGUID)`	Remove the metadata element representing a port.
`void`	`removeProcess(String processGUID, String processExternalIdentifier)`	Remove the metadata element representing a process.
`void`	`removeSchemaAttribute(String schemaAttributeGUID)`	Remove the metadata element representing a schema attribute.
`void`	`removeSchemaType(String schemaTypeGUID)`	Remove the metadata element representing a schema type.
`void`	`setBusinessSignificant(String elementGUID)`	Classify a port, process or asset as "BusinessSignificant" (this may effect the way that lineage is displayed).
`void`	`setDataAssetAsReferenceData(String assetGUID)`	Classify the data asset to indicate that it can be used as reference data.
`void`	`setSchemaElementAsCalculatedValue(boolean assetManagerIsHome, String schemaElementGUID, String formula)`	Classify the schema type (or attribute if type is embedded) to indicate that it is a calculated value.
`void`	`setupColumnAsPrimaryKey(boolean assetManagerIsHome, String schemaAttributeGUID, String schemaAttributeExternalIdentifier, String primaryKeyName, KeyPattern primaryKeyPattern)`	Classify the column schema attribute to indicate that it describes a primary key.
`String`	`setupControlFlow(boolean assetManagerIsHome, String currentStepGUID, String nextStepGUID, String qualifiedName, String description, String guard)`	Link two elements to show that when one completes the next is started.
`String`	`setupDataFlow(boolean assetManagerIsHome, String dataSupplierGUID, String dataConsumerGUID, String qualifiedName, String description, String formula)`	Link two elements together to show that data flows from one to the other.
`void`	`setupForeignKeyRelationship(boolean assetManagerIsHome, String primaryKeyGUID, String foreignKeyGUID, ForeignKeyProperties foreignKeyProperties)`	Link two schema attributes together to show a foreign key relationship.
`void`	`setupLineageMapping(String sourceElementGUID, String destinationElementGUID)`	Link to elements together to show that they are part of the lineage of the data that is moving between the processes.
`void`	`setupPortDelegation(boolean assetManagerIsHome, String portOneGUID, String portTwoGUID)`	Link two ports together to show that portTwo is an implementation of portOne.
`void`	`setupPortSchemaType(boolean assetManagerIsHome, String portGUID, String schemaTypeGUID)`	Link a schema type to a port to show the structure of data it accepts.
`String`	`setupProcessCall(boolean assetManagerIsHome, String callerGUID, String calledGUID, String qualifiedName, String description, String formula)`	Link two elements together to show a request-response call between them.
`void`	`setupProcessParent(String userId, String assetManagerGUID, String assetManagerName, boolean assetManagerIsHome, String parentProcessGUID, String childProcessGUID, ProcessContainmentType containmentType)`	Create a parent-child relationship between two processes.
`void`	`setupProcessPort(boolean assetManagerIsHome, String processGUID, String portGUID)`	Link a port to a process.
`void`	`setupSchemaTypeParent(boolean assetManagerIsHome, String schemaTypeGUID, String parentElementGUID, String parentElementTypeName)`	Connect a schema type to a data asset, process or port.
`void`	`updateControlFlow(String controlFlowGUID, String qualifiedName, String description, String guard)`	Update the relationship between two elements that shows that when one completes the next is started.
`void`	`updateDataAsset(String assetGUID, boolean isMergeUpdate, DataAssetProperties assetProperties)`	Update the metadata element representing a data source.
`void`	`updateDataFlow(String dataFlowGUID, String qualifiedName, String description, String formula)`	Update relationship between two elements that shows that data flows from one to the other.
`void`	`updateForeignKeyRelationship(String primaryKeyGUID, String foreignKeyGUID, ForeignKeyProperties foreignKeyProperties)`	Update the relationship properties for the query target.
`void`	`updatePort(String portGUID, PortProperties portProperties)`	Update the properties of the metadata element representing a port.
`void`	`updateProcess(String processGUID, boolean isMergeUpdate, ProcessProperties processProperties)`	Update the metadata element representing a process.
`void`	`updateProcessCall(String processCallGUID, String qualifiedName, String description, String formula)`	Update the relationship between two elements that shows a request-response call between them.
`void`	`updateProcessStatus(String processGUID, ProcessStatus processStatus)`	Update the status of the metadata element representing a process.
`void`	`updateSchemaAttribute(String schemaAttributeGUID, boolean isMergeUpdate, SchemaAttributeProperties schemaAttributeProperties)`	Update the properties of the metadata element representing a schema attribute.
`void`	`updateSchemaType(String schemaTypeGUID, boolean isMergeUpdate, SchemaTypeProperties schemaTypeProperties)`	Update the metadata element representing a schema type.
`void`	`withdrawDataAsset(String assetGUID)`	Update the zones for the data asset so that it is no longer visible to consumers.
`void`	`withdrawProcess(String processGUID)`	Update the zones for the asset so that it is no longer visible to consumers.

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

- Constructor Detail
  - LineageIntegratorContext
```
public LineageIntegratorContext(DataAssetExchangeClient dataAssetExchangeClient,
                                LineageExchangeClient lineageExchangeClient,
                                String userId,
                                String assetManagerGUID,
                                String assetManagerName,
                                String connectorName,
                                String integrationServiceName,
                                AuditLog auditLog)
```
    Create a new context for a connector.
    
    Parameters:
    
    dataAssetExchangeClient - client for data asset requests
    
    lineageExchangeClient - client for lineage requests
    
    userId - integration daemon's userId
    
    assetManagerGUID - unique identifier of the software server capability for the asset manager
    
    assetManagerName - unique name of the software server capability for the asset manager
    
    connectorName - name of the connector using this context
    
    integrationServiceName - name of this service
    
    auditLog - logging destination
- Method Detail
  - createDataAsset
```
public String createDataAsset(boolean assetManagerIsHome,
                              DataAssetProperties assetProperties)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              PropertyServerException
```
    Create a new metadata element to represent the root of a data asset.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this asset
    
    assetProperties - properties to store
    
    Returns:
    
    unique identifier of the new metadata element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - createDataAssetFromTemplate
```
public String createDataAssetFromTemplate(boolean assetManagerIsHome,
                                          String templateGUID,
                                          TemplateProperties templateProperties)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          PropertyServerException
```
    Create a new metadata element to represent an asset using an existing metadata element as a template. The template defines additional classifications and relationships that should be added to the new asset.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this asset
    
    templateGUID - unique identifier of the metadata element to copy
    
    templateProperties - properties that override the template
    
    Returns:
    
    unique identifier of the new metadata element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updateDataAsset
```
public void updateDataAsset(String assetGUID,
                            boolean isMergeUpdate,
                            DataAssetProperties assetProperties)
                     throws InvalidParameterException,
                            UserNotAuthorizedException,
                            PropertyServerException
```
    Update the metadata element representing a data source.
    
    Parameters:
    
    assetGUID - unique identifier of the metadata element to update
    
    isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
    
    assetProperties - new properties for this element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - publishDataAsset
```
public void publishDataAsset(String assetGUID)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException
```
    Update the zones for the data asset so that it becomes visible to consumers. (The zones are set to the list of zones in the publishedZones option configured for each instance of the Asset Manager OMAS).
    
    Parameters:
    
    assetGUID - unique identifier of the metadata element to publish
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - withdrawDataAsset
```
public void withdrawDataAsset(String assetGUID)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              PropertyServerException
```
    Update the zones for the data asset so that it is no longer visible to consumers. (The zones are set to the list of zones in the defaultZones option configured for each instance of the Asset Manager OMAS. This is the setting when the database is first created).
    
    Parameters:
    
    assetGUID - unique identifier of the metadata element to withdraw
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - removeDataAsset
```
public void removeDataAsset(String assetGUID)
                     throws InvalidParameterException,
                            UserNotAuthorizedException,
                            PropertyServerException
```
    Remove the metadata element representing a data asset. This will delete the asset and all anchored elements such as schema and comments.
    
    Parameters:
    
    assetGUID - unique identifier of the metadata element to remove
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setDataAssetAsReferenceData
```
public void setDataAssetAsReferenceData(String assetGUID)
                                 throws InvalidParameterException,
                                        UserNotAuthorizedException,
                                        PropertyServerException
```
    Classify the data asset to indicate that it can be used as reference data.
    
    Parameters:
    
    assetGUID - unique identifier of the metadata element to update
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearDataAssetAsReferenceData
```
public void clearDataAssetAsReferenceData(String assetGUID)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          PropertyServerException
```
    Remove the reference data designation from the asset.
    
    Parameters:
    
    assetGUID - unique identifier of the metadata element to update
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - findDataAssets
```
public List<DataAssetElement> findDataAssets(String searchString,
                                             int startFrom,
                                             int pageSize)
                                      throws InvalidParameterException,
                                             UserNotAuthorizedException,
                                             PropertyServerException
```
    Retrieve the list of data asset metadata elements that contain the search string. The search string is treated as a regular expression.
    
    Parameters:
    
    searchString - string to find in the properties
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getDataAssetsByName
```
public List<DataAssetElement> getDataAssetsByName(String name,
                                                  int startFrom,
                                                  int pageSize)
                                           throws InvalidParameterException,
                                                  UserNotAuthorizedException,
                                                  PropertyServerException
```
    Retrieve the list of data asset metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
    
    Parameters:
    
    name - name to search for
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getDataAssetsForAssetManager
```
public List<DataAssetElement> getDataAssetsForAssetManager(int startFrom,
                                                           int pageSize)
                                                    throws InvalidParameterException,
                                                           UserNotAuthorizedException,
                                                           PropertyServerException
```
    Retrieve the list of assets created on behalf of this asset manager.
    
    Parameters:
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getDataAssetByGUID
```
public DataAssetElement getDataAssetByGUID(String openMetadataGUID)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           PropertyServerException
```
    Retrieve the asset metadata element with the supplied unique identifier.
    
    Parameters:
    
    openMetadataGUID - unique identifier of the requested metadata element
    
    Returns:
    
    matching metadata element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - createSchemaType
```
public String createSchemaType(boolean assetManagerIsHome,
                               String schemaTypeGUID,
                               SchemaTypeProperties schemaTypeProperties)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               PropertyServerException
```
    Create a new metadata element to represent a schema type.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this schema element
    
    schemaTypeGUID - unique identifier of the schemaType where the schema type is located
    
    schemaTypeProperties - properties about the schema type to store
    
    Returns:
    
    unique identifier of the new schema type
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - createSchemaTypeFromTemplate
```
public String createSchemaTypeFromTemplate(boolean assetManagerIsHome,
                                           String templateGUID,
                                           TemplateProperties templateProperties)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           PropertyServerException
```
    Create a new metadata element to represent a schema type using an existing metadata element as a template.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this schema element
    
    templateGUID - unique identifier of the metadata element to copy
    
    templateProperties - properties that override the template
    
    Returns:
    
    unique identifier of the new schema type
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updateSchemaType
```
public void updateSchemaType(String schemaTypeGUID,
                             boolean isMergeUpdate,
                             SchemaTypeProperties schemaTypeProperties)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException
```
    Update the metadata element representing a schema type.
    
    Parameters:
    
    schemaTypeGUID - unique identifier of the metadata element to update
    
    isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
    
    schemaTypeProperties - new properties for the metadata element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setupSchemaTypeParent
```
public void setupSchemaTypeParent(boolean assetManagerIsHome,
                                  String schemaTypeGUID,
                                  String parentElementGUID,
                                  String parentElementTypeName)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException
```
    Connect a schema type to a data asset, process or port.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this relationship
    
    schemaTypeGUID - unique identifier of the schema type to connect
    
    parentElementGUID - unique identifier of the open metadata element that this schema type is to be connected to
    
    parentElementTypeName - unique type name of the open metadata element that this schema type is to be connected to
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearSchemaTypeParent
```
public void clearSchemaTypeParent(String schemaTypeGUID,
                                  String parentElementGUID,
                                  String parentElementTypeName)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException
```
    Remove the relationship between a schema type and its parent data asset, process or port.
    
    Parameters:
    
    schemaTypeGUID - unique identifier of the schema type to connect
    
    parentElementGUID - unique identifier of the open metadata element that this schema type is to be connected to
    
    parentElementTypeName - unique type name of the open metadata element that this schema type is to be connected to
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - removeSchemaType
```
public void removeSchemaType(String schemaTypeGUID)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException
```
    Remove the metadata element representing a schema type.
    
    Parameters:
    
    schemaTypeGUID - unique identifier of the metadata element to remove
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - findSchemaType
```
public List<SchemaTypeElement> findSchemaType(String searchString,
                                              int startFrom,
                                              int pageSize)
                                       throws InvalidParameterException,
                                              UserNotAuthorizedException,
                                              PropertyServerException
```
    Retrieve the list of schema type metadata elements that contain the search string. The search string is treated as a regular expression.
    
    Parameters:
    
    searchString - string to find in the properties
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getSchemaTypeForElement
```
public SchemaTypeElement getSchemaTypeForElement(String parentElementGUID,
                                                 String parentElementTypeName)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 PropertyServerException
```
    Return the schema type associated with a specific open metadata element (data asset, process or port).
    
    Parameters:
    
    parentElementGUID - unique identifier of the open metadata element that this schema type is to be connected to
    
    parentElementTypeName - unique type name of the open metadata element that this schema type is to be connected to
    
    Returns:
    
    metadata element describing the schema type associated with the requested parent element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getSchemaTypeByName
```
public List<SchemaTypeElement> getSchemaTypeByName(String name,
                                                   int startFrom,
                                                   int pageSize)
                                            throws InvalidParameterException,
                                                   UserNotAuthorizedException,
                                                   PropertyServerException
```
    Retrieve the list of schema type metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
    
    Parameters:
    
    name - name to search for
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getSchemaTypeByGUID
```
public SchemaTypeElement getSchemaTypeByGUID(String schemaTypeGUID)
                                      throws InvalidParameterException,
                                             UserNotAuthorizedException,
                                             PropertyServerException
```
    Retrieve the schema type metadata element with the supplied unique identifier.
    
    Parameters:
    
    schemaTypeGUID - unique identifier of the requested metadata element
    
    Returns:
    
    requested metadata element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getSchemaTypeParent
```
public ElementHeader getSchemaTypeParent(String schemaTypeGUID)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
```
    Retrieve the header of the metadata element connected to a schema type.
    
    Parameters:
    
    schemaTypeGUID - unique identifier of the requested metadata element
    
    Returns:
    
    header for parent element (data asset, process, port)
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - createSchemaAttribute
```
public String createSchemaAttribute(boolean assetManagerIsHome,
                                    String schemaElementGUID,
                                    SchemaAttributeProperties schemaAttributeProperties)
                             throws InvalidParameterException,
                                    UserNotAuthorizedException,
                                    PropertyServerException
```
    Create a new metadata element to represent a schema attribute.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this schema attribute
    
    schemaElementGUID - unique identifier of the schemaType or Schema Attribute where the schema attribute is connected to
    
    schemaAttributeProperties - properties for the schema attribute
    
    Returns:
    
    unique identifier of the new metadata element for the schema attribute
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - createSchemaAttributeFromTemplate
```
public String createSchemaAttributeFromTemplate(boolean assetManagerIsHome,
                                                String schemaElementGUID,
                                                String templateGUID,
                                                TemplateProperties templateProperties)
                                         throws InvalidParameterException,
                                                UserNotAuthorizedException,
                                                PropertyServerException
```
    Create a new metadata element to represent a schema attribute using an existing metadata element as a template.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this schema attribute
    
    schemaElementGUID - unique identifier of the schemaType or Schema Attribute where the schema attribute is connected to
    
    templateGUID - unique identifier of the metadata element to copy
    
    templateProperties - properties that override the template
    
    Returns:
    
    unique identifier of the new metadata element for the schema attribute
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updateSchemaAttribute
```
public void updateSchemaAttribute(String schemaAttributeGUID,
                                  boolean isMergeUpdate,
                                  SchemaAttributeProperties schemaAttributeProperties)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException
```
    Update the properties of the metadata element representing a schema attribute.
    
    Parameters:
    
    schemaAttributeGUID - unique identifier of the schema attribute to update
    
    isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
    
    schemaAttributeProperties - new properties for the schema attribute
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setSchemaElementAsCalculatedValue
```
public void setSchemaElementAsCalculatedValue(boolean assetManagerIsHome,
                                              String schemaElementGUID,
                                              String formula)
                                       throws InvalidParameterException,
                                              UserNotAuthorizedException,
                                              PropertyServerException
```
    Classify the schema type (or attribute if type is embedded) to indicate that it is a calculated value.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this schema attribute
    
    schemaElementGUID - unique identifier of the metadata element to update
    
    formula - description of how the value is calculated
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearSchemaElementAsCalculatedValue
```
public void clearSchemaElementAsCalculatedValue(String schemaElementGUID)
                                         throws InvalidParameterException,
                                                UserNotAuthorizedException,
                                                PropertyServerException
```
    Remove the calculated value designation from the schema element.
    
    Parameters:
    
    schemaElementGUID - unique identifier of the metadata element to update
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setupColumnAsPrimaryKey
```
public void setupColumnAsPrimaryKey(boolean assetManagerIsHome,
                                    String schemaAttributeGUID,
                                    String schemaAttributeExternalIdentifier,
                                    String primaryKeyName,
                                    KeyPattern primaryKeyPattern)
                             throws InvalidParameterException,
                                    UserNotAuthorizedException,
                                    PropertyServerException
```
    Classify the column schema attribute to indicate that it describes a primary key.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this classification
    
    schemaAttributeGUID - unique identifier of the metadata element to update
    
    schemaAttributeExternalIdentifier - unique identifier of the schema attribute in the external asset manager
    
    primaryKeyName - name of the primary key (if different from the column name)
    
    primaryKeyPattern - key pattern used to maintain the primary key
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearColumnAsPrimaryKey
```
public void clearColumnAsPrimaryKey(String schemaAttributeGUID)
                             throws InvalidParameterException,
                                    UserNotAuthorizedException,
                                    PropertyServerException
```
    Remove the primary key designation from the schema attribute.
    
    Parameters:
    
    schemaAttributeGUID - unique identifier of the metadata element to update
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setupForeignKeyRelationship
```
public void setupForeignKeyRelationship(boolean assetManagerIsHome,
                                        String primaryKeyGUID,
                                        String foreignKeyGUID,
                                        ForeignKeyProperties foreignKeyProperties)
                                 throws InvalidParameterException,
                                        UserNotAuthorizedException,
                                        PropertyServerException
```
    Link two schema attributes together to show a foreign key relationship.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this relationship
    
    primaryKeyGUID - unique identifier of the derived schema element
    
    foreignKeyGUID - unique identifier of the query target schema element
    
    foreignKeyProperties - properties for the foreign key relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updateForeignKeyRelationship
```
public void updateForeignKeyRelationship(String primaryKeyGUID,
                                         String foreignKeyGUID,
                                         ForeignKeyProperties foreignKeyProperties)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
```
    Update the relationship properties for the query target.
    
    Parameters:
    
    primaryKeyGUID - unique identifier of the derived schema element
    
    foreignKeyGUID - unique identifier of the query target schema element
    
    foreignKeyProperties - properties for the foreign key relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearForeignKeyRelationship
```
public void clearForeignKeyRelationship(String primaryKeyGUID,
                                        String foreignKeyGUID)
                                 throws InvalidParameterException,
                                        UserNotAuthorizedException,
                                        PropertyServerException
```
    Remove the foreign key relationship between two schema elements.
    
    Parameters:
    
    primaryKeyGUID - unique identifier of the derived schema element
    
    foreignKeyGUID - unique identifier of the query target schema element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - removeSchemaAttribute
```
public void removeSchemaAttribute(String schemaAttributeGUID)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException
```
    Remove the metadata element representing a schema attribute.
    
    Parameters:
    
    schemaAttributeGUID - unique identifier of the metadata element to remove
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - findSchemaAttributes
```
public List<SchemaAttributeElement> findSchemaAttributes(String searchString,
                                                         int startFrom,
                                                         int pageSize)
                                                  throws InvalidParameterException,
                                                         UserNotAuthorizedException,
                                                         PropertyServerException
```
    Retrieve the list of schema attribute metadata elements that contain the search string. The search string is treated as a regular expression.
    
    Parameters:
    
    searchString - string to find in the properties
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getAttributesForSchemaType
```
public List<SchemaAttributeElement> getAttributesForSchemaType(String schemaTypeGUID,
                                                               int startFrom,
                                                               int pageSize)
                                                        throws InvalidParameterException,
                                                               UserNotAuthorizedException,
                                                               PropertyServerException
```
    Retrieve the list of schema attributes associated with a schemaType.
    
    Parameters:
    
    schemaTypeGUID - unique identifier of the schemaType of interest
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of associated metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getSchemaAttributesByName
```
public List<SchemaAttributeElement> getSchemaAttributesByName(String name,
                                                              int startFrom,
                                                              int pageSize)
                                                       throws InvalidParameterException,
                                                              UserNotAuthorizedException,
                                                              PropertyServerException
```
    Retrieve the list of schema attribute metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
    
    Parameters:
    
    name - name to search for
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getSchemaAttributeByGUID
```
public SchemaAttributeElement getSchemaAttributeByGUID(String schemaAttributeGUID)
                                                throws InvalidParameterException,
                                                       UserNotAuthorizedException,
                                                       PropertyServerException
```
    Retrieve the schema attribute metadata element with the supplied unique identifier.
    
    Parameters:
    
    schemaAttributeGUID - unique identifier of the requested metadata element
    
    Returns:
    
    matching metadata element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - createProcess
```
public String createProcess(boolean assetManagerIsHome,
                            ProcessProperties processProperties,
                            ProcessStatus initialStatus)
                     throws InvalidParameterException,
                            UserNotAuthorizedException,
                            PropertyServerException
```
    Create a new metadata element to represent a process.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this process
    
    processProperties - properties about the process to store
    
    initialStatus - status value for the new process (default = ACTIVE)
    
    Returns:
    
    unique identifier of the new process
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - createProcessFromTemplate
```
public String createProcessFromTemplate(boolean assetManagerIsHome,
                                        String templateGUID,
                                        TemplateProperties templateProperties)
                                 throws InvalidParameterException,
                                        UserNotAuthorizedException,
                                        PropertyServerException
```
    Create a new metadata element to represent a process using an existing metadata element as a template.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this process
    
    templateGUID - unique identifier of the metadata element to copy
    
    templateProperties - properties that override the template
    
    Returns:
    
    unique identifier of the new process
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updateProcess
```
public void updateProcess(String processGUID,
                          boolean isMergeUpdate,
                          ProcessProperties processProperties)
                   throws InvalidParameterException,
                          UserNotAuthorizedException,
                          PropertyServerException
```
    Update the metadata element representing a process.
    
    Parameters:
    
    processGUID - unique identifier of the metadata element to update
    
    isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
    
    processProperties - new properties for the metadata element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updateProcessStatus
```
public void updateProcessStatus(String processGUID,
                                ProcessStatus processStatus)
                         throws InvalidParameterException,
                                UserNotAuthorizedException,
                                PropertyServerException
```
    Update the status of the metadata element representing a process.
    
    Parameters:
    
    processGUID - unique identifier of the process to update
    
    processStatus - new status for the process
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setupProcessParent
```
public void setupProcessParent(String userId,
                               String assetManagerGUID,
                               String assetManagerName,
                               boolean assetManagerIsHome,
                               String parentProcessGUID,
                               String childProcessGUID,
                               ProcessContainmentType containmentType)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               PropertyServerException
```
    Create a parent-child relationship between two processes.
    
    Parameters:
    
    userId - calling user
    
    assetManagerGUID - unique identifier of software server capability representing the caller
    
    assetManagerName - unique name of software server capability representing the caller
    
    assetManagerIsHome - ensure that only the asset manager can update this asset
    
    parentProcessGUID - unique identifier of the process in the external asset manager that is to be the parent process
    
    childProcessGUID - unique identifier of the process in the external asset manager that is to be the nested sub-process
    
    containmentType - describes the ownership of the sub-process
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearProcessParent
```
public void clearProcessParent(String parentProcessGUID,
                               String childProcessGUID)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               PropertyServerException
```
    Remove a parent-child relationship between two processes.
    
    Parameters:
    
    parentProcessGUID - unique identifier of the process in the external asset manager that is to be the parent process
    
    childProcessGUID - unique identifier of the process in the external asset manager that is to be the nested sub-process
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - publishProcess
```
public void publishProcess(String processGUID)
                    throws InvalidParameterException,
                           UserNotAuthorizedException,
                           PropertyServerException
```
    Update the zones for the asset so that it becomes visible to consumers. (The zones are set to the list of zones in the publishedZones option configured for each instance of the Asset Manager OMAS).
    
    Parameters:
    
    processGUID - unique identifier of the metadata element to publish
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - withdrawProcess
```
public void withdrawProcess(String processGUID)
                     throws InvalidParameterException,
                            UserNotAuthorizedException,
                            PropertyServerException
```
    Update the zones for the asset so that it is no longer visible to consumers. (The zones are set to the list of zones in the defaultZones option configured for each instance of the Asset Manager OMAS. This is the setting when the process is first created).
    
    Parameters:
    
    processGUID - unique identifier of the metadata element to withdraw
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - removeProcess
```
public void removeProcess(String processGUID,
                          String processExternalIdentifier)
                   throws InvalidParameterException,
                          UserNotAuthorizedException,
                          PropertyServerException
```
    Remove the metadata element representing a process.
    
    Parameters:
    
    processGUID - unique identifier of the metadata element to remove
    
    processExternalIdentifier - unique identifier of the process in the external asset manager
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - findProcesses
```
public List<ProcessElement> findProcesses(String searchString,
                                          int startFrom,
                                          int pageSize)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          PropertyServerException
```
    Retrieve the list of process metadata elements that contain the search string. The search string is treated as a regular expression.
    
    Parameters:
    
    searchString - string to find in the properties
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getProcessesForAssetManager
```
public List<ProcessElement> getProcessesForAssetManager(int startFrom,
                                                        int pageSize)
                                                 throws InvalidParameterException,
                                                        UserNotAuthorizedException,
                                                        PropertyServerException
```
    Return the list of processes associated with the asset manager.
    
    Parameters:
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of metadata elements describing the processes associated with the requested asset manager
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getProcessesByName
```
public List<ProcessElement> getProcessesByName(String name,
                                               int startFrom,
                                               int pageSize)
                                        throws InvalidParameterException,
                                               UserNotAuthorizedException,
                                               PropertyServerException
```
    Retrieve the list of process metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
    
    Parameters:
    
    name - name to search for
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getProcessByGUID
```
public ProcessElement getProcessByGUID(String processGUID)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException
```
    Retrieve the process metadata element with the supplied unique identifier.
    
    Parameters:
    
    processGUID - unique identifier of the requested metadata element
    
    Returns:
    
    requested metadata element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getProcessParent
```
public ProcessElement getProcessParent(String processGUID)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException
```
    Retrieve the process metadata element with the supplied unique identifier.
    
    Parameters:
    
    processGUID - unique identifier of the requested metadata element
    
    Returns:
    
    parent process element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getSubProcesses
```
public List<ProcessElement> getSubProcesses(String processGUID,
                                            int startFrom,
                                            int pageSize)
                                     throws InvalidParameterException,
                                            UserNotAuthorizedException,
                                            PropertyServerException
```
    Retrieve the process metadata element with the supplied unique identifier.
    
    Parameters:
    
    processGUID - unique identifier of the requested metadata element
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of process element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - createPort
```
public String createPort(boolean assetManagerIsHome,
                         String processGUID,
                         PortProperties portProperties)
                  throws InvalidParameterException,
                         UserNotAuthorizedException,
                         PropertyServerException
```
    Create a new metadata element to represent a port.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this port
    
    processGUID - unique identifier of the process where the port is located
    
    portProperties - properties for the port
    
    Returns:
    
    unique identifier of the new metadata element for the port
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updatePort
```
public void updatePort(String portGUID,
                       PortProperties portProperties)
                throws InvalidParameterException,
                       UserNotAuthorizedException,
                       PropertyServerException
```
    Update the properties of the metadata element representing a port. This call replaces all existing properties with the supplied properties.
    
    Parameters:
    
    portGUID - unique identifier of the port to update
    
    portProperties - new properties for the port
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setupProcessPort
```
public void setupProcessPort(boolean assetManagerIsHome,
                             String processGUID,
                             String portGUID)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException
```
    Link a port to a process.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this asset
    
    processGUID - unique identifier of the process
    
    portGUID - unique identifier of the port
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearProcessPort
```
public void clearProcessPort(String processGUID,
                             String portGUID)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException
```
    Unlink a port from a process.
    
    Parameters:
    
    processGUID - unique identifier of the process
    
    portGUID - unique identifier of the port
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setupPortDelegation
```
public void setupPortDelegation(boolean assetManagerIsHome,
                                String portOneGUID,
                                String portTwoGUID)
                         throws InvalidParameterException,
                                UserNotAuthorizedException,
                                PropertyServerException
```
    Link two ports together to show that portTwo is an implementation of portOne. (That is, portOne delegates to portTwo.)
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this asset
    
    portOneGUID - unique identifier of the port at end 1
    
    portTwoGUID - unique identifier of the port at end 2
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearPortDelegation
```
public void clearPortDelegation(String portOneGUID,
                                String portTwoGUID)
                         throws InvalidParameterException,
                                UserNotAuthorizedException,
                                PropertyServerException
```
    Remove the port delegation relationship between two ports.
    
    Parameters:
    
    portOneGUID - unique identifier of the port at end 1
    
    portTwoGUID - unique identifier of the port at end 2
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setupPortSchemaType
```
public void setupPortSchemaType(boolean assetManagerIsHome,
                                String portGUID,
                                String schemaTypeGUID)
                         throws InvalidParameterException,
                                UserNotAuthorizedException,
                                PropertyServerException
```
    Link a schema type to a port to show the structure of data it accepts.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this asset
    
    portGUID - unique identifier of the port
    
    schemaTypeGUID - unique identifier of the schemaType
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearPortSchemaType
```
public void clearPortSchemaType(String portGUID,
                                String schemaTypeGUID)
                         throws InvalidParameterException,
                                UserNotAuthorizedException,
                                PropertyServerException
```
    Remove the schema type from a port.
    
    Parameters:
    
    portGUID - unique identifier of the port
    
    schemaTypeGUID - unique identifier of the schemaType
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - removePort
```
public void removePort(String portGUID)
                throws InvalidParameterException,
                       UserNotAuthorizedException,
                       PropertyServerException
```
    Remove the metadata element representing a port.
    
    Parameters:
    
    portGUID - unique identifier of the metadata element to remove
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - findPorts
```
public List<PortElement> findPorts(String searchString,
                                   int startFrom,
                                   int pageSize)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException
```
    Retrieve the list of port metadata elements that contain the search string. The search string is treated as a regular expression.
    
    Parameters:
    
    searchString - string to find in the properties
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getPortsForProcess
```
public List<PortElement> getPortsForProcess(String processGUID,
                                            int startFrom,
                                            int pageSize)
                                     throws InvalidParameterException,
                                            UserNotAuthorizedException,
                                            PropertyServerException
```
    Retrieve the list of ports associated with a process.
    
    Parameters:
    
    processGUID - unique identifier of the process of interest
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of associated metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getPortUse
```
public List<PortElement> getPortUse(String portGUID,
                                    int startFrom,
                                    int pageSize)
                             throws InvalidParameterException,
                                    UserNotAuthorizedException,
                                    PropertyServerException
```
    Retrieve the list of ports that delegate to this port.
    
    Parameters:
    
    portGUID - unique identifier of the starting port
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of associated metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getPortDelegation
```
public PortElement getPortDelegation(String portGUID)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     PropertyServerException
```
    Retrieve the port that this port delegates to.
    
    Parameters:
    
    portGUID - unique identifier of the starting port alias
    
    Returns:
    
    matching metadata element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getPortsByName
```
public List<PortElement> getPortsByName(String name,
                                        int startFrom,
                                        int pageSize)
                                 throws InvalidParameterException,
                                        UserNotAuthorizedException,
                                        PropertyServerException
```
    Retrieve the list of port metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
    
    Parameters:
    
    name - name to search for
    
    startFrom - paging start point
    
    pageSize - maximum results that can be returned
    
    Returns:
    
    list of matching metadata elements
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getPortByGUID
```
public PortElement getPortByGUID(String portGUID)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 PropertyServerException
```
    Retrieve the port metadata element with the supplied unique identifier.
    
    Parameters:
    
    portGUID - unique identifier of the requested metadata element
    
    Returns:
    
    matching metadata element
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setBusinessSignificant
```
public void setBusinessSignificant(String elementGUID)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException
```
    Classify a port, process or asset as "BusinessSignificant" (this may effect the way that lineage is displayed).
    
    Parameters:
    
    elementGUID - unique identifier of the metadata element to update
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearBusinessSignificant
```
public void clearBusinessSignificant(String elementGUID)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     PropertyServerException
```
    Remove the "BusinessSignificant" designation from the element.
    
    Parameters:
    
    elementGUID - unique identifier of the metadata element to update
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setupDataFlow
```
public String setupDataFlow(boolean assetManagerIsHome,
                            String dataSupplierGUID,
                            String dataConsumerGUID,
                            String qualifiedName,
                            String description,
                            String formula)
                     throws InvalidParameterException,
                            UserNotAuthorizedException,
                            PropertyServerException
```
    Link two elements together to show that data flows from one to the other.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this asset
    
    dataSupplierGUID - unique identifier of the data supplier
    
    dataConsumerGUID - unique identifier of the data consumer
    
    qualifiedName - unique identifier for this relationship
    
    description - description and/or purpose of the data flow
    
    formula - function that determines the subset of the data that flows
    
    Returns:
    
    unique identifier of the relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getDataFlow
```
public DataFlowElement getDataFlow(String dataSupplierGUID,
                                   String dataConsumerGUID,
                                   String qualifiedName)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException
```
    Retrieve the data flow relationship between two elements. The qualifiedName is optional unless there is more than one data flow relationships between these two elements since it is used to disambiguate the request. This is often used in conjunction with update.
    
    Parameters:
    
    dataSupplierGUID - unique identifier of the data supplier
    
    dataConsumerGUID - unique identifier of the data consumer
    
    qualifiedName - unique identifier for this relationship
    
    Returns:
    
    unique identifier and properties of the relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updateDataFlow
```
public void updateDataFlow(String dataFlowGUID,
                           String qualifiedName,
                           String description,
                           String formula)
                    throws InvalidParameterException,
                           UserNotAuthorizedException,
                           PropertyServerException
```
    Update relationship between two elements that shows that data flows from one to the other.
    
    Parameters:
    
    dataFlowGUID - unique identifier of the data flow relationship
    
    qualifiedName - unique identifier for this relationship
    
    description - description and/or purpose of the data flow
    
    formula - function that determines the subset of the data that flows
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearDataFlow
```
public void clearDataFlow(String dataFlowGUID)
                   throws InvalidParameterException,
                          UserNotAuthorizedException,
                          PropertyServerException
```
    Remove the data flow relationship between two elements.
    
    Parameters:
    
    dataFlowGUID - unique identifier of the data flow relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getDataFlowConsumers
```
public List<DataFlowElement> getDataFlowConsumers(String dataSupplierGUID)
                                           throws InvalidParameterException,
                                                  UserNotAuthorizedException,
                                                  PropertyServerException
```
    Retrieve the data flow relationships linked from an specific element to the downstream consumers.
    
    Parameters:
    
    dataSupplierGUID - unique identifier of the data supplier
    
    Returns:
    
    unique identifier and properties of the relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getDataFlowSuppliers
```
public List<DataFlowElement> getDataFlowSuppliers(String dataConsumerGUID)
                                           throws InvalidParameterException,
                                                  UserNotAuthorizedException,
                                                  PropertyServerException
```
    Retrieve the data flow relationships linked from an specific element to the upstream suppliers.
    
    Parameters:
    
    dataConsumerGUID - unique identifier of the data consumer
    
    Returns:
    
    unique identifier and properties of the relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setupControlFlow
```
public String setupControlFlow(boolean assetManagerIsHome,
                               String currentStepGUID,
                               String nextStepGUID,
                               String qualifiedName,
                               String description,
                               String guard)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               PropertyServerException
```
    Link two elements to show that when one completes the next is started.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this asset
    
    currentStepGUID - unique identifier of the previous step
    
    nextStepGUID - unique identifier of the next step
    
    qualifiedName - unique identifier for this relationship
    
    description - description and/or purpose of the data flow
    
    guard - function that must be true to travel down this control flow
    
    Returns:
    
    unique identifier for the control flow relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getControlFlow
```
public ControlFlowElement getControlFlow(String currentStepGUID,
                                         String nextStepGUID,
                                         String qualifiedName)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
```
    Retrieve the control flow relationship between two elements. The qualifiedName is optional unless there is more than one control flow relationships between these two elements since it is used to disambiguate the request. This is often used in conjunction with update.
    
    Parameters:
    
    currentStepGUID - unique identifier of the previous step
    
    nextStepGUID - unique identifier of the next step
    
    qualifiedName - unique identifier for this relationship
    
    Returns:
    
    unique identifier and properties of the relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updateControlFlow
```
public void updateControlFlow(String controlFlowGUID,
                              String qualifiedName,
                              String description,
                              String guard)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              PropertyServerException
```
    Update the relationship between two elements that shows that when one completes the next is started.
    
    Parameters:
    
    controlFlowGUID - unique identifier of the control flow relationship
    
    qualifiedName - unique identifier for this relationship
    
    description - description and/or purpose of the data flow
    
    guard - function that must be true to travel down this control flow
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearControlFlow
```
public void clearControlFlow(String controlFlowGUID)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException
```
    Remove the control flow relationship between two elements.
    
    Parameters:
    
    controlFlowGUID - unique identifier of the control flow relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getControlFlowNextSteps
```
public List<ControlFlowElement> getControlFlowNextSteps(String currentStepGUID)
                                                 throws InvalidParameterException,
                                                        UserNotAuthorizedException,
                                                        PropertyServerException
```
    Retrieve the control relationships linked from an specific element to the possible next elements in the process.
    
    Parameters:
    
    currentStepGUID - unique identifier of the current step
    
    Returns:
    
    unique identifier and properties of the relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getControlFlowPreviousSteps
```
public List<ControlFlowElement> getControlFlowPreviousSteps(String currentStepGUID)
                                                     throws InvalidParameterException,
                                                            UserNotAuthorizedException,
                                                            PropertyServerException
```
    Retrieve the control relationships linked from an specific element to the possible previous elements in the process.
    
    Parameters:
    
    currentStepGUID - unique identifier of the current step
    
    Returns:
    
    unique identifier and properties of the relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setupProcessCall
```
public String setupProcessCall(boolean assetManagerIsHome,
                               String callerGUID,
                               String calledGUID,
                               String qualifiedName,
                               String description,
                               String formula)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               PropertyServerException
```
    Link two elements together to show a request-response call between them.
    
    Parameters:
    
    assetManagerIsHome - ensure that only the asset manager can update this asset
    
    callerGUID - unique identifier of the element that is making the call
    
    calledGUID - unique identifier of the element that is processing the call
    
    qualifiedName - unique identifier for this relationship
    
    description - description and/or purpose of the data flow
    
    formula - function that determines the subset of the data that flows
    
    Returns:
    
    unique identifier of the new relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getProcessCall
```
public ProcessCallElement getProcessCall(String callerGUID,
                                         String calledGUID,
                                         String qualifiedName)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
```
    Retrieve the process call relationship between two elements. The qualifiedName is optional unless there is more than one process call relationships between these two elements since it is used to disambiguate the request. This is often used in conjunction with update.
    
    Parameters:
    
    callerGUID - unique identifier of the element that is making the call
    
    calledGUID - unique identifier of the element that is processing the call
    
    qualifiedName - unique identifier for this relationship
    
    Returns:
    
    unique identifier and properties of the relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - updateProcessCall
```
public void updateProcessCall(String processCallGUID,
                              String qualifiedName,
                              String description,
                              String formula)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              PropertyServerException
```
    Update the relationship between two elements that shows a request-response call between them.
    
    Parameters:
    
    processCallGUID - unique identifier of the process call relationship
    
    qualifiedName - unique identifier for this relationship
    
    description - description and/or purpose of the data flow
    
    formula - function that determines the subset of the data that flows
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearProcessCall
```
public void clearProcessCall(String processCallGUID)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException
```
    Remove the process call relationship.
    
    Parameters:
    
    processCallGUID - unique identifier of the process call relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getProcessCalled
```
public List<ProcessCallElement> getProcessCalled(String callerGUID)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 PropertyServerException
```
    Retrieve the process call relationships linked from an specific element to the elements it calls.
    
    Parameters:
    
    callerGUID - unique identifier of the element that is making the call
    
    Returns:
    
    unique identifier and properties of the relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - getProcessCallers
```
public List<ProcessCallElement> getProcessCallers(String calledGUID)
                                           throws InvalidParameterException,
                                                  UserNotAuthorizedException,
                                                  PropertyServerException
```
    Retrieve the process call relationships linked from an specific element to its callers.
    
    Parameters:
    
    calledGUID - unique identifier of the element that is processing the call
    
    Returns:
    
    unique identifier and properties of the relationship
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - setupLineageMapping
```
public void setupLineageMapping(String sourceElementGUID,
                                String destinationElementGUID)
                         throws InvalidParameterException,
                                UserNotAuthorizedException,
                                PropertyServerException
```
    Link to elements together to show that they are part of the lineage of the data that is moving between the processes. Typically the lineage relationships stitch together processes and data assets supported by different technologies.
    
    Parameters:
    
    sourceElementGUID - unique identifier of the source
    
    destinationElementGUID - unique identifier of the destination
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)
  - clearLineageMapping
```
public void clearLineageMapping(String sourceElementGUID,
                                String destinationElementGUID)
                         throws InvalidParameterException,
                                UserNotAuthorizedException,
                                PropertyServerException
```
    Remove the lineage mapping between two elements.
    
    Parameters:
    
    sourceElementGUID - unique identifier of the source
    
    destinationElementGUID - unique identifier of the destination
    
    Throws:
    
    InvalidParameterException - one of the parameters is invalid
    
    UserNotAuthorizedException - the user is not authorized to issue this request
    
    PropertyServerException - there is a problem reported in the open metadata server(s)

Class LineageIntegratorContext

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

LineageIntegratorContext

Method Detail

createDataAsset

createDataAssetFromTemplate

updateDataAsset

publishDataAsset

withdrawDataAsset

removeDataAsset

setDataAssetAsReferenceData

clearDataAssetAsReferenceData

findDataAssets

getDataAssetsByName

getDataAssetsForAssetManager

getDataAssetByGUID

createSchemaType

createSchemaTypeFromTemplate

updateSchemaType

setupSchemaTypeParent

clearSchemaTypeParent

removeSchemaType

findSchemaType

getSchemaTypeForElement

getSchemaTypeByName

getSchemaTypeByGUID

getSchemaTypeParent

createSchemaAttribute

createSchemaAttributeFromTemplate

updateSchemaAttribute

setSchemaElementAsCalculatedValue

clearSchemaElementAsCalculatedValue

setupColumnAsPrimaryKey

clearColumnAsPrimaryKey

setupForeignKeyRelationship

updateForeignKeyRelationship

clearForeignKeyRelationship

removeSchemaAttribute

findSchemaAttributes

getAttributesForSchemaType

getSchemaAttributesByName

getSchemaAttributeByGUID

createProcess

createProcessFromTemplate

updateProcess

updateProcessStatus

setupProcessParent

clearProcessParent

publishProcess

withdrawProcess

removeProcess

findProcesses

getProcessesForAssetManager

getProcessesByName

getProcessByGUID

getProcessParent

getSubProcesses

createPort

updatePort

setupProcessPort

clearProcessPort

setupPortDelegation

clearPortDelegation

setupPortSchemaType

clearPortSchemaType

removePort

findPorts

getPortsForProcess

getPortUse

getPortDelegation

getPortsByName

getPortByGUID

setBusinessSignificant

clearBusinessSignificant

setupDataFlow

getDataFlow

updateDataFlow