'Decrypts a single block of encrypted data.
The DECRYPT operation decrypts a well-formed block of ciphertext using
the target encryption key and specified algorithm. This operation is
the reverse of the ENCRYPT operation; only a single block of data may
be decrypted, the size of this block is dependent on the target key and
the algorithm to be used. The DECRYPT operation applies to asymmetric
and symmetric keys stored in Azure Key Vault since it uses the private
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: algorithm identifier. Possible values include:
\'RSA-OAEP\', \'RSA-OAEP-256\', \'RSA1_5\'
:type algorithm: str or :class:`JsonWebKeyEncryptionAlgorithm
<azure.keyvault.models.JsonWebKeyEncryptionAlgorithm>`
:param value:
:type value: 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:`KeyOperationResult
<azure.keyvault.models.KeyOperationResult>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`KeyVaultErrorException<azure.keyvault.models.KeyVaultErrorException>`'

def decrypt(self, vault_base_url, key_name, key_version, algorithm, value, custom_headers=None, raw=False, **operation_config):

    parameters = models.KeyOperationsParameters(algorithm=algorithm, value=value)
    url = '/keys/{key-name}/{key-version}/decrypt'
    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, 'KeyOperationsParameters')
    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('KeyOperationResult', response)
    if raw:
        client_raw_response = ClientRawResponse(deserialized, response)
        return client_raw_response
    return deserialized
