'Unwraps a symmetric key using the specified key that was initially used
for wrapping that key.
The UNWRAP operation supports decryption of a symmetric key using the
target key encryption key. This operation is the reverse of the WRAP
operation. The UNWRAP 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 unwrap_key(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}/unwrapkey'
    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
