'Creates a new key, stores it, then returns key parameters and
attributes to the client.
The create key operation can be used to create any key type in Azure
Key Vault. If the named key already exists, Azure Key Vault creates a
new version 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 for the new key. The system will generate
the version name for the new key.
:type key_name: str
:param kty: The type of key to create. For valid key types, see
JsonWebKeyType. Supported JsonWebKey key types (kty) for Elliptic
Curve, RSA, HSM, Octet. Possible values include: \'EC\', \'RSA\',
\'RSA-HSM\', \'oct\'
:type kty: str or :class:`JsonWebKeyType
<azure.keyvault.models.JsonWebKeyType>`
:param key_size: The key size in bytes. For example, 1024 or 2048.
:type key_size: int
:param key_ops:
:type key_ops: list of str or :class:`JsonWebKeyOperation
<azure.keyvault.models.JsonWebKeyOperation>`
:param key_attributes:
:type key_attributes: :class:`KeyAttributes
<azure.keyvault.models.KeyAttributes>`
:param tags: Application specific metadata in the form of key-value
pairs.
:type tags: dict
: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 create_key(self, vault_base_url, key_name, kty, key_size=None, key_ops=None, key_attributes=None, tags=None, custom_headers=None, raw=False, **operation_config):

    parameters = models.KeyCreateParameters(kty=kty, key_size=key_size, key_ops=key_ops, key_attributes=key_attributes, tags=tags)
    url = '/keys/{key-name}/create'
    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', pattern='^[0-9a-zA-Z-]+$')}
    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, 'KeyCreateParameters')
    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
