Package org.odpi.openmetadata.accessservices.digitalarchitecture.server.spring

Class ValidValuesResource

  • @RestController
@RequestMapping("/servers/{serverName}/open-metadata/access-services/digital-architecture/users/{userId}")
public class ValidValuesResource
extends Object
    ValidValuesResource provides the API operations to create and maintain lists of valid value definitions grouped into a valid value set. Both valid value definitions and valid value sets have the same attributes and so inherit from ValidValue where all of the attributes are defined. A set is just grouping of valid values. Valid value definitions and set can be nested many times in other valid value sets.

    • Constructor Detail

      • ValidValuesResource

        public ValidValuesResource()
        Default constructor

    • Method Detail

      • createValidValueSet

        @PostMapping(path="/valid-values/sets")
public GUIDResponse createValidValueSet​(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @RequestBody
                                        ValidValueProperties requestBody)
        Create a new valid value set. This just creates the Set itself. Members are added either as they are created, or they can be attached to a set after they are created.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        requestBody - parameters for the new object.
        Returns:
        unique identifier for the new set or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • createValidValueDefinition

        @PostMapping(path="/valid-values/sets/{setGUID}")
public GUIDResponse createValidValueDefinition​(@PathVariable
                                               String serverName,
                                               @PathVariable
                                               String userId,
                                               @PathVariable
                                               String setGUID,
                                               @RequestBody
                                               ValidValueProperties requestBody)
        Create a new valid value definition.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        setGUID - unique identifier of the set to attach this to.
        requestBody - parameters for the new object.
        Returns:
        unique identifier for the new definition InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • updateValidValue

        @PostMapping(path="/valid-values/{validValueGUID}/update")
public VoidResponse updateValidValue​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String validValueGUID,
                                     @RequestBody
                                     ValidValueProperties requestBody)
        Update the properties of the valid value. All properties are updated. If only changing some if the properties, retrieve the current values from the repository and pass existing values back on this call if they are not to change.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        validValueGUID - unique identifier of the valid value.
        requestBody - parameters to update.
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • deleteValidValue

        @PostMapping(path="/valid-values/{validValueGUID}/delete")
public VoidResponse deleteValidValue​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String validValueGUID,
                                     @RequestBody
                                     String qualifiedName)
        Remove the valid value form the repository. All links to it are deleted too.
        Parameters:
        serverName - name of calling server
        userId - calling user
        validValueGUID - unique identifier of the value to delete
        qualifiedName - unique name of the value to delete. This is used to verify that the correct valid value is being deleted.
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • attachValidValueToSet

        @PostMapping(path="/valid-values/sets/{setGUID}/members/{validValueGUID}")
public VoidResponse attachValidValueToSet​(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String setGUID,
                                          @PathVariable
                                          String validValueGUID,
                                          @RequestBody(required=false)
                                          NullRequestBody requestBody)
        Create a link between a valid value set or definition and a set. This means the valid value is a member of the set.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        setGUID - unique identifier of the set.
        validValueGUID - unique identifier of the valid value to add to the set.
        requestBody - null request body supplied to satisfy REST protocol
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • detachValidValueFromSet

        @PostMapping(path="/valid-values/sets/{setGUID}/members/{validValueGUID}/delete")
public VoidResponse detachValidValueFromSet​(@PathVariable
                                            String serverName,
                                            @PathVariable
                                            String userId,
                                            @PathVariable
                                            String setGUID,
                                            @PathVariable
                                            String validValueGUID,
                                            @RequestBody(required=false)
                                            NullRequestBody requestBody)
        Remove the link between a valid value and a set it is a member of.
        Parameters:
        serverName - name of calling server
        userId - calling user
        setGUID - owning set
        validValueGUID - unique identifier of the member to be removed.
        requestBody - null request body supplied to satisfy REST protocol
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • linkValidValueToImplementation

        @PostMapping(path="/valid-values/{validValueGUID}/implementations/{assetGUID}")
public VoidResponse linkValidValueToImplementation​(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @PathVariable
                                                   String validValueGUID,
                                                   @PathVariable
                                                   String assetGUID,
                                                   @RequestBody
                                                   ValidValuesImplProperties requestBody)
        Link a valid value to an asset that provides the implementation. Typically this method is used to link a valid value set to a code table.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        validValueGUID - unique identifier of the valid value.
        assetGUID - unique identifier of the asset that implements the valid value.
        requestBody - implementation relationship properties
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • classifyAssetAsReferenceData

        @PostMapping(path="/assets/{assetGUID}/classify-as-reference-data")
public VoidResponse classifyAssetAsReferenceData​(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @PathVariable
                                                 String assetGUID,
                                                 @RequestBody(required=false)
                                                 NullRequestBody requestBody)
        Add the ReferenceData classification to an asset. IF the asset is already classified in this way, the method is a no-op.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        assetGUID - unique identifier of the asset that contains reference data.
        requestBody - null request body supplied to satisfy REST protocol
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • unlinkValidValueFromImplementation

        @PostMapping(path="/valid-values/{validValueGUID}/implementations/{assetGUID}/delete")
public VoidResponse unlinkValidValueFromImplementation​(@PathVariable
                                                       String serverName,
                                                       @PathVariable
                                                       String userId,
                                                       @PathVariable
                                                       String validValueGUID,
                                                       @PathVariable
                                                       String assetGUID,
                                                       @RequestBody(required=false)
                                                       NullRequestBody requestBody)
        Remove the link between a valid value and an implementing asset.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        validValueGUID - unique identifier of the valid value.
        assetGUID - unique identifier of the asset that used to implement the valid value.
        requestBody - null request body supplied to satisfy REST protocol
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • declassifyAssetAsReferenceData

        @PostMapping(path="/assets/{assetGUID}/declassify-as-reference-data")
public VoidResponse declassifyAssetAsReferenceData​(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @PathVariable
                                                   String assetGUID,
                                                   @RequestBody(required=false)
                                                   NullRequestBody requestBody)
        Remove the ReferenceData classification form an Asset. If the asset was not classified in this way, this call is a no-op.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        assetGUID - unique identifier of asset.
        requestBody - null request body supplied to satisfy REST protocol
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • assignValidValueToConsumer

        @PostMapping(path="/valid-values/{validValueGUID}/consumers/{consumerGUID}")
public VoidResponse assignValidValueToConsumer​(@PathVariable
                                               String serverName,
                                               @PathVariable
                                               String userId,
                                               @PathVariable
                                               String validValueGUID,
                                               @PathVariable
                                               String consumerGUID,
                                               @RequestBody
                                               ValidValueAssignmentProperties requestBody)
        Link a valid value typically to a schema element or glossary term to show that it uses the valid values.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        validValueGUID - unique identifier of the valid value.
        consumerGUID - unique identifier of the element to link to.
        requestBody - request body supplied to pass the strictRequirement flag
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • unassignValidValueFromConsumer

        @PostMapping(path="/valid-values/{validValueGUID}/consumers/{consumerGUID}/delete")
public VoidResponse unassignValidValueFromConsumer​(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @PathVariable
                                                   String validValueGUID,
                                                   @PathVariable
                                                   String consumerGUID,
                                                   @RequestBody(required=false)
                                                   NullRequestBody requestBody)
        Remove the link between a valid value and a consumer.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        validValueGUID - unique identifier of the valid value.
        consumerGUID - unique identifier of the element to remove the link from.
        requestBody - null request body supplied to satisfy REST protocol
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • assignReferenceValueToItem

        @PostMapping(path="/reference-values/{validValueGUID}/items/{referenceableGUID}")
public VoidResponse assignReferenceValueToItem​(@PathVariable
                                               String serverName,
                                               @PathVariable
                                               String userId,
                                               @PathVariable
                                               String validValueGUID,
                                               @PathVariable
                                               String referenceableGUID,
                                               @RequestBody
                                               ReferenceValueAssignmentProperties requestBody)
        Link a valid value as a reference value to a referencable to act as a tag/classification to help with locating and grouping the referenceable.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        validValueGUID - unique identifier of the valid value.
        referenceableGUID - unique identifier of the element to link to.
        requestBody - properties for the relationship.
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • unassignReferenceValueFromItem

        @PostMapping(path="/reference-values/{validValueGUID}/items/{referenceableGUID}/delete")
public VoidResponse unassignReferenceValueFromItem​(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @PathVariable
                                                   String validValueGUID,
                                                   @PathVariable
                                                   String referenceableGUID,
                                                   @RequestBody(required=false)
                                                   NullRequestBody requestBody)
        Remove the reference value link between a valid value and a referenceable (item).
        Parameters:
        serverName - name of calling server
        userId - calling user.
        validValueGUID - unique identifier of the valid value.
        referenceableGUID - unique identifier of the element to remove the link from.
        requestBody - null request body supplied to satisfy REST protocol
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • mapValidValues

        @PostMapping(path="/valid-values/{validValue1GUID}/map/{validValue2GUID}")
public VoidResponse mapValidValues​(@PathVariable
                                   String serverName,
                                   @PathVariable
                                   String userId,
                                   @PathVariable
                                   String validValue1GUID,
                                   @PathVariable
                                   String validValue2GUID,
                                   @RequestBody
                                   ValidValuesMappingProperties requestBody)
        Link together 2 valid values from different sets that have equivalent values/meanings.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        validValue1GUID - unique identifier of the valid value.
        validValue2GUID - unique identifier of the other valid value to link to.
        requestBody - properties for the relationship.
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • unmapValidValues

        @PostMapping(path="/valid-values/{validValue1GUID}/map/{validValue2GUID}/delete")
public VoidResponse unmapValidValues​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String validValue1GUID,
                                     @PathVariable
                                     String validValue2GUID,
                                     @RequestBody(required=false)
                                     NullRequestBody requestBody)
        Remove the reference value link between a valid value and a referenceable (item).
        Parameters:
        serverName - name of calling server
        userId - calling user.
        validValue1GUID - unique identifier of the valid value.
        validValue2GUID - unique identifier of the other valid value element to remove the link from.
        requestBody - null request body supplied to satisfy REST protocol
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • getValidValueByGUID

        @GetMapping(path="/valid-values/{validValueGUID}")
public ValidValueResponse getValidValueByGUID​(@PathVariable
                                              String serverName,
                                              @PathVariable
                                              String userId,
                                              @PathVariable
                                              String validValueGUID)
        Retrieve a specific valid value from the repository.
        Parameters:
        serverName - name of calling server
        userId - calling user
        validValueGUID - unique identifier of the valid value.
        Returns:
        Valid value bean or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • getValidValueByName

        @PostMapping(path="/valid-values/by-name")
public ValidValuesResponse getValidValueByName​(@PathVariable
                                               String serverName,
                                               @PathVariable
                                               String userId,
                                               @RequestParam
                                               int startFrom,
                                               @RequestParam
                                               int pageSize,
                                               @RequestBody
                                               NameRequestBody requestBody)
        Retrieve a specific valid value from the repository. Duplicates may be returned if multiple valid values have been assigned the same qualified name.
        Parameters:
        serverName - name of calling server
        userId - calling user
        requestBody - qualified name of the valid value.
        startFrom - paging starting point
        pageSize - maximum number of return values.
        Returns:
        Valid value beans or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • findValidValues

        @PostMapping(path="/valid-values/by-search-string")
public ValidValuesResponse findValidValues​(@PathVariable
                                           String serverName,
                                           @PathVariable
                                           String userId,
                                           @RequestParam
                                           int startFrom,
                                           @RequestParam
                                           int pageSize,
                                           @RequestBody
                                           SearchStringRequestBody requestBody)
        Locate valid values that match the search string. It considers the names, description, scope, usage and preferred value.
        Parameters:
        serverName - name of calling server
        userId - calling user
        startFrom - paging starting point
        pageSize - maximum number of return values.
        requestBody - string value to look for - may contain RegEx characters.
        Returns:
        list of valid value beans or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • getValidValueSetMembers

        @GetMapping(path="/valid-values/sets/{validValueSetGUID}/members")
public ValidValuesResponse getValidValueSetMembers​(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @PathVariable
                                                   String validValueSetGUID,
                                                   @RequestParam
                                                   int startFrom,
                                                   @RequestParam
                                                   int pageSize)
        Page through the members of a valid value set.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        validValueSetGUID - unique identifier of the valid value set.
        startFrom - paging starting point
        pageSize - maximum number of return values.
        Returns:
        list of valid value beans or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • getSetsForValidValue

        @GetMapping(path="/valid-values/{validValueGUID}/set-membership")
public ValidValuesResponse getSetsForValidValue​(@PathVariable
                                                String serverName,
                                                @PathVariable
                                                String userId,
                                                @PathVariable
                                                String validValueGUID,
                                                @RequestParam
                                                int startFrom,
                                                @RequestParam
                                                int pageSize)
        Page through the list of valid value sets that a valid value definition/set belongs to.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        validValueGUID - unique identifier of valid value to query
        startFrom - paging starting point
        pageSize - maximum number of return values.
        Returns:
        list of valid value beans or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • getValidValuesAssignmentConsumers

        @GetMapping(path="/valid-values/{validValueGUID}/consumers")
public ValidValueAssignmentConsumersResponse getValidValuesAssignmentConsumers​(@PathVariable
                                                                               String serverName,
                                                                               @PathVariable
                                                                               String userId,
                                                                               @PathVariable
                                                                               String validValueGUID,
                                                                               @RequestParam
                                                                               int startFrom,
                                                                               @RequestParam
                                                                               int pageSize)
        Page through the list of consumers for a valid value.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        validValueGUID - unique identifier of valid value to query
        startFrom - paging starting point
        pageSize - maximum number of return values.
        Returns:
        list of consumers beans or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • getValidValuesAssignmentDefinition

        @GetMapping(path="/referenceables/{referenceableGUID}/valid-value-assignments")
public ValidValueAssignmentDefinitionsResponse getValidValuesAssignmentDefinition​(@PathVariable
                                                                                  String serverName,
                                                                                  @PathVariable
                                                                                  String userId,
                                                                                  @PathVariable
                                                                                  String referenceableGUID,
                                                                                  @RequestParam
                                                                                  int startFrom,
                                                                                  @RequestParam
                                                                                  int pageSize)
        Page through the list of valid values assigned to referenceable element.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        referenceableGUID - unique identifier of anchoring referenceable
        startFrom - paging starting point
        pageSize - maximum number of return values.
        Returns:
        list of consumers beans or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • getValidValuesImplementationAssets

        @GetMapping(path="/valid-values/{validValueGUID}/implementations")
public ValidValuesImplAssetsResponse getValidValuesImplementationAssets​(@PathVariable
                                                                        String serverName,
                                                                        @PathVariable
                                                                        String userId,
                                                                        @PathVariable
                                                                        String validValueGUID,
                                                                        @RequestParam
                                                                        int startFrom,
                                                                        @RequestParam
                                                                        int pageSize)
        Page through the list of implementations for a valid value.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        validValueGUID - unique identifier of valid value to query
        startFrom - paging starting point
        pageSize - maximum number of return values.
        Returns:
        list of asset beans or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • getValidValuesImplementationDefinitions

        @GetMapping(path="/assets/{assetGUID}/valid-value-implementation-definitions")
public ValidValuesImplDefinitionsResponse getValidValuesImplementationDefinitions​(@PathVariable
                                                                                  String serverName,
                                                                                  @PathVariable
                                                                                  String userId,
                                                                                  @PathVariable
                                                                                  String assetGUID,
                                                                                  @RequestParam
                                                                                  int startFrom,
                                                                                  @RequestParam
                                                                                  int pageSize)
        Page through the list of valid values defining the content of a reference data asset. This is always called from the assetHandler after it has checked that the asset is in the right zone.
        Parameters:
        serverName - name of calling server
        userId - calling user
        assetGUID - unique identifier of asset to query
        startFrom - paging starting point
        pageSize - maximum number of return values.
        Returns:
        list of valid value beans or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • getValidValueMappings

        @GetMapping(path="/valid-values/{validValueGUID}/mapped-values")
public ValidValueMappingsResponse getValidValueMappings​(@PathVariable
                                                        String serverName,
                                                        @PathVariable
                                                        String userId,
                                                        @PathVariable
                                                        String validValueGUID,
                                                        @RequestParam
                                                        int startFrom,
                                                        @RequestParam
                                                        int pageSize)
        Page through the list of mappings for a valid value. These are other valid values from different valid value sets that are equivalent in some way. The association description covers the type of association.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        validValueGUID - unique identifier of valid value to query
        startFrom - paging starting point
        pageSize - maximum number of return values.
        Returns:
        list of mappings to other valid value beans or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • getValidValuesMappings

        @GetMapping(path="/valid-values/{validValueGUID}/map-relationships")
public ValidValuesMappingsResponse getValidValuesMappings​(@PathVariable
                                                          String serverName,
                                                          @PathVariable
                                                          String userId,
                                                          @PathVariable
                                                          String validValueGUID,
                                                          @RequestParam
                                                          int startFrom,
                                                          @RequestParam
                                                          int pageSize)
        Page through the list of mapping relationships associated with a valid value. These are other valid values from different valid value sets that are equivalent in some way. The association description covers the type of association.
        Parameters:
        serverName - name of calling server
        userId - calling user.
        validValueGUID - unique identifier of valid value to query
        startFrom - paging starting point
        pageSize - maximum number of return values.
        Returns:
        list of mappings to other valid value beans or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • getReferenceValueAssignedItems

        @GetMapping(path="/valid-values/{validValueGUID}/reference-values/assigned-items")
public ReferenceValueAssignmentItemsResponse getReferenceValueAssignedItems​(@PathVariable
                                                                            String serverName,
                                                                            @PathVariable
                                                                            String userId,
                                                                            @PathVariable
                                                                            String validValueGUID,
                                                                            @RequestParam
                                                                            int startFrom,
                                                                            @RequestParam
                                                                            int pageSize)
        Page through the list of referenceables that have this valid value as a reference value.
        Parameters:
        serverName - name of calling server
        userId - calling user
        validValueGUID - unique identifier of valid value to query
        startFrom - paging starting point
        pageSize - maximum number of return values.
        Returns:
        list of referenceable beans or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.

      • getReferenceValueAssignments

        @GetMapping(path="/referenceables/{referenceableGUID}/reference-value-assignments")
public ReferenceValueAssignmentDefinitionsResponse getReferenceValueAssignments​(@PathVariable
                                                                                String serverName,
                                                                                @PathVariable
                                                                                String userId,
                                                                                @PathVariable
                                                                                String referenceableGUID,
                                                                                @RequestParam
                                                                                int startFrom,
                                                                                @RequestParam
                                                                                int pageSize)
        Page through the list of assigned reference values for a referenceable.
        Parameters:
        serverName - name of calling server
        userId - calling user
        referenceableGUID - unique identifier of assigned item
        startFrom - paging starting point
        pageSize - maximum number of return values.
        Returns:
        list of valid value beans or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to make this request or PropertyServerException the repository is not available or not working properly.