'Verifies a signature using a specified key.
The VERIFY operation is applicable to symmetric keys stored in Azure
Key Vault. VERIFY is not strictly necessary for asymmetric keys stored
in Azure Key Vault since signature verification can be performed using
the public portion of the key but this operation is supported as a
convenience for callers that only have a key-reference and not the
public portion of the key.
:param vault_base_url: The vault name, for example
https://myvault.vault.azure.net.
:type vault_base_url: str
:param key_name: The name of the key.
:type key_name: str
:param key_version: The version of the key.
:type key_version: str
:param algorithm: The signing/verification algorithm. For more
information on possible algorithm types, see
JsonWebKeySignatureAlgorithm. Possible values include: \'PS256\',
\'PS384\', \'PS512\', \'RS256\', \'RS384\', \'RS512\', \'RSNULL\'
:type algorithm: str or :class:`JsonWebKeySignatureAlgorithm
<azure.keyvault.models.JsonWebKeySignatureAlgorithm>`
:param digest: The digest used for signing.
:type digest: bytes
:param signature: The signature to be verified.
:type signature: bytes
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`KeyVerifyResult
<azure.keyvault.models.KeyVerifyResult>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`KeyVaultErrorException<azure.keyvault.models.KeyVaultErrorException>`'

def verify(self, vault_base_url, key_name, key_version, algorithm, digest, signature, custom_headers=None, raw=False, **operation_config):

    parameters = models.KeyVerifyParameters(algorithm=algorithm, digest=digest, signature=signature)
    url = '/keys/{key-name}/{key-version}/verify'
    path_format_arguments = {'vaultBaseUrl': self._serialize.url('vault_base_url', vault_base_url, 'str', skip_quote=True), 'key-name': self._serialize.url('key_name', key_name, 'str'), 'key-version': self._serialize.url('key_version', key_version, 'str')}
    url = self._client.format_url(url, **path_format_arguments)
    query_parameters = {}
    query_parameters['api-version'] = self._serialize.query('self.api_version', self.api_version, 'str')
    header_parameters = {}
    header_parameters['Content-Type'] = 'application/json;    charset=utf-8'
    if self.config.generate_client_request_id:
        header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
    if custom_headers:
        header_parameters.update(custom_headers)
    if (self.config.accept_language is not None):
        header_parameters['accept-language'] = self._serialize.header('self.config.accept_language', self.config.accept_language, 'str')
    body_content = self._serialize.body(parameters, 'KeyVerifyParameters')
    request = self._client.post(url, query_parameters)
    response = self._client.send(request, header_parameters, body_content, **operation_config)
    if (response.status_code not in [200]):
        raise models.KeyVaultErrorException(self._deserialize, response)
    deserialized = None
    if (response.status_code == 200):
        deserialized = self._deserialize('KeyVerifyResult', response)
    if raw:
        client_raw_response = ClientRawResponse(deserialized, response)
        return client_raw_response
    return deserialized
