'Encrypts an arbitrary sequence of bytes using an encryption key that is
stored in a key vault.
The ENCRYPT operation encrypts an arbitrary sequence of bytes using an
encryption key that is stored in Azure Key Vault. Note that the ENCRYPT
operation only supports a single block of data, the size of which is
dependent on the target key and the encryption algorithm to be used.
The ENCRYPT operation is only strictly necessary for symmetric keys
stored in Azure Key Vault since protection with an asymmetric key can
be performed using public portion of the key. This operation is
supported for asymmetric keys as a convenience for callers that have a
key-reference but do not have access to the public key material.
: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 encrypt(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}/encrypt'
    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
