'Restores a backed up key to a vault.
Imports a previously backed up key into Azure Key Vault, restoring the
key, its key identifier, attributes and access control policies. The
RESTORE operation may be used to import a previously backed up key.
Individual versions of a key cannot be restored. The key is restored in
its entirety with the same key name as it had when it was backed up. If
the key name is not available in the target Key Vault, the RESTORE
operation will be rejected. While the key name is retained during
restore, the final key identifier will change if the key is restored to
a different vault. Restore will restore all versions and preserve
version identifiers. The RESTORE operation is subject to security
constraints: The target Key Vault must be owned by the same Microsoft
Azure Subscription as the source Key Vault The user must have RESTORE
permission in the target Key Vault.
:param vault_base_url: The vault name, for example
https://myvault.vault.azure.net.
:type vault_base_url: str
:param key_bundle_backup: The backup blob associated with a key
bundle.
:type key_bundle_backup: 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:`KeyBundle <azure.keyvault.models.KeyBundle>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`KeyVaultErrorException<azure.keyvault.models.KeyVaultErrorException>`'

def restore_key(self, vault_base_url, key_bundle_backup, custom_headers=None, raw=False, **operation_config):

    parameters = models.KeyRestoreParameters(key_bundle_backup=key_bundle_backup)
    url = '/keys/restore'
    path_format_arguments = {'vaultBaseUrl': self._serialize.url('vault_base_url', vault_base_url, 'str', skip_quote=True)}
    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, 'KeyRestoreParameters')
    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('KeyBundle', response)
    if raw:
        client_raw_response = ClientRawResponse(deserialized, response)
        return client_raw_response
    return deserialized
