text: # coding=utf-8
  # --------------------------------------------------------------------------
  # Copyright (c) Microsoft Corporation. All rights reserved.
  # Licensed under the MIT License. See License.txt in the project root for
  # license information.
  #
  # Code generated by Microsoft (R) AutoRest Code Generator.
  # Changes may cause incorrect behavior and will be lost if the code is
  # regenerated.
  # --------------------------------------------------------------------------
  
  import uuid
  from msrest.pipeline import ClientRawResponse
  from msrestazure.azure_exceptions import CloudError
  from msrest.polling import LROPoller, NoPolling
  from msrestazure.polling.arm_polling import ARMPolling
  
  from .. import models
  
  
  class StorageAccountsOperations(object):
      """StorageAccountsOperations operations.
  
      You should not instantiate directly this class, but create a Client instance that will create it for you and attach it as attribute.
  
      :param client: Client for service requests.
      :param config: Configuration of service client.
      :param serializer: An object model serializer.
      :param deserializer: An object model deserializer.
      :ivar api_version: Client Api Version. Constant value: "2017-06-01".
      """
  
      models = models
  
      def __init__(self, client, config, serializer, deserializer):
  
          self._client = client
          self._serialize = serializer
          self._deserialize = deserializer
          self.api_version = "2017-06-01"
  
          self.config = config
  
      def check_name_availability(
              self, name, custom_headers=None, raw=False, **operation_config):
          """Checks that the storage account name is valid and is not already in
          use.
  
          :param name: The storage account name.
          :type name: str
          :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>`.
          :return: CheckNameAvailabilityResult or ClientRawResponse if raw=true
          :rtype:
           ~azure.mgmt.storage.v2017_06_01.models.CheckNameAvailabilityResult or
           ~msrest.pipeline.ClientRawResponse
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          account_name = models.StorageAccountCheckNameAvailabilityParameters(name=name)
  
          # Construct URL
          url = self.check_name_availability.metadata['url']
          path_format_arguments = {
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          header_parameters['Accept'] = 'application/json'
          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')
  
          # Construct body
          body_content = self._serialize.body(account_name, 'StorageAccountCheckNameAvailabilityParameters')
  
          # Construct and send request
          request = self._client.post(url, query_parameters, header_parameters, body_content)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [200]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('CheckNameAvailabilityResult', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
      check_name_availability.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Storage/checkNameAvailability'}
  
  
      def _create_initial(
              self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.create.metadata['url']
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'accountName': self._serialize.url("account_name", account_name, 'str', max_length=24, min_length=3),
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          header_parameters['Accept'] = 'application/json'
          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')
  
          # Construct body
          body_content = self._serialize.body(parameters, 'StorageAccountCreateParameters')
  
          # Construct and send request
          request = self._client.put(url, query_parameters, header_parameters, body_content)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [200, 202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
  
          if response.status_code == 200:
              deserialized = self._deserialize('StorageAccount', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def create(
              self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):
          """Asynchronously creates a new storage account with the specified
          parameters. If an account is already created and a subsequent create
          request is issued with different properties, the account properties
          will be updated. If an account is already created and a subsequent
          create or update request is issued with the exact same set of
          properties, the request will succeed.
  
          :param resource_group_name: The name of the resource group within the
           user's subscription. The name is case insensitive.
          :type resource_group_name: str
          :param account_name: The name of the storage account within the
           specified resource group. Storage account names must be between 3 and
           24 characters in length and use numbers and lower-case letters only.
          :type account_name: str
          :param parameters: The parameters to provide for the created account.
          :type parameters:
           ~azure.mgmt.storage.v2017_06_01.models.StorageAccountCreateParameters
          :param dict custom_headers: headers that will be added to the request
          :param bool raw: The poller return type is ClientRawResponse, the
           direct response alongside the deserialized response
          :param polling: True for ARMPolling, False for no polling, or a
           polling object for personal polling strategy
          :return: An instance of LROPoller that returns StorageAccount or
           ClientRawResponse<StorageAccount> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.storage.v2017_06_01.models.StorageAccount]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.storage.v2017_06_01.models.StorageAccount]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._create_initial(
              resource_group_name=resource_group_name,
              account_name=account_name,
              parameters=parameters,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('StorageAccount', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  return client_raw_response
  
              return deserialized
  
          lro_delay = operation_config.get(
              'long_running_operation_timeout',
              self.config.long_running_operation_timeout)
          if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
      create.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}'}
  
      def delete(
              self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):
          """Deletes a storage account in Microsoft Azure.
  
          :param resource_group_name: The name of the resource group within the
           user's subscription. The name is case insensitive.
          :type resource_group_name: str
          :param account_name: The name of the storage account within the
           specified resource group. Storage account names must be between 3 and
           24 characters in length and use numbers and lower-case letters only.
          :type account_name: str
          :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>`.
          :return: None or ClientRawResponse if raw=true
          :rtype: None or ~msrest.pipeline.ClientRawResponse
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          # Construct URL
          url = self.delete.metadata['url']
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'accountName': self._serialize.url("account_name", account_name, 'str', max_length=24, min_length=3),
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          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')
  
          # Construct and send request
          request = self._client.delete(url, query_parameters, header_parameters)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [200, 204]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          if raw:
              client_raw_response = ClientRawResponse(None, response)
              return client_raw_response
      delete.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}'}
  
      def get_properties(
              self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):
          """Returns the properties for the specified storage account including but
          not limited to name, SKU name, location, and account status. The
          ListKeys operation should be used to retrieve storage keys.
  
          :param resource_group_name: The name of the resource group within the
           user's subscription. The name is case insensitive.
          :type resource_group_name: str
          :param account_name: The name of the storage account within the
           specified resource group. Storage account names must be between 3 and
           24 characters in length and use numbers and lower-case letters only.
          :type account_name: str
          :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>`.
          :return: StorageAccount or ClientRawResponse if raw=true
          :rtype: ~azure.mgmt.storage.v2017_06_01.models.StorageAccount or
           ~msrest.pipeline.ClientRawResponse
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          # Construct URL
          url = self.get_properties.metadata['url']
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'accountName': self._serialize.url("account_name", account_name, 'str', max_length=24, min_length=3),
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          header_parameters['Accept'] = 'application/json'
          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')
  
          # Construct and send request
          request = self._client.get(url, query_parameters, header_parameters)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [200]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('StorageAccount', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
      get_properties.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}'}
  
      def update(
              self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, **operation_config):
          """The update operation can be used to update the SKU, encryption, access
          tier, or tags for a storage account. It can also be used to map the
          account to a custom domain. Only one custom domain is supported per
          storage account; the replacement/change of custom domain is not
          supported. In order to replace an old custom domain, the old value must
          be cleared/unregistered before a new value can be set. The update of
          multiple properties is supported. This call does not change the storage
          keys for the account. If you want to change the storage account keys,
          use the regenerate keys operation. The location and name of the storage
          account cannot be changed after creation.
  
          :param resource_group_name: The name of the resource group within the
           user's subscription. The name is case insensitive.
          :type resource_group_name: str
          :param account_name: The name of the storage account within the
           specified resource group. Storage account names must be between 3 and
           24 characters in length and use numbers and lower-case letters only.
          :type account_name: str
          :param parameters: The parameters to provide for the updated account.
          :type parameters:
           ~azure.mgmt.storage.v2017_06_01.models.StorageAccountUpdateParameters
          :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>`.
          :return: StorageAccount or ClientRawResponse if raw=true
          :rtype: ~azure.mgmt.storage.v2017_06_01.models.StorageAccount or
           ~msrest.pipeline.ClientRawResponse
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          # Construct URL
          url = self.update.metadata['url']
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'accountName': self._serialize.url("account_name", account_name, 'str', max_length=24, min_length=3),
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          header_parameters['Accept'] = 'application/json'
          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')
  
          # Construct body
          body_content = self._serialize.body(parameters, 'StorageAccountUpdateParameters')
  
          # Construct and send request
          request = self._client.patch(url, query_parameters, header_parameters, body_content)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [200]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('StorageAccount', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
      update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}'}
  
      def list(
              self, custom_headers=None, raw=False, **operation_config):
          """Lists all the storage accounts available under the subscription. Note
          that storage keys are not returned; use the ListKeys operation for
          this.
  
          :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>`.
          :return: An iterator like instance of StorageAccount
          :rtype:
           ~azure.mgmt.storage.v2017_06_01.models.StorageAccountPaged[~azure.mgmt.storage.v2017_06_01.models.StorageAccount]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          def prepare_request(next_link=None):
              if not next_link:
                  # Construct URL
                  url = self.list.metadata['url']
                  path_format_arguments = {
                      'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
                  }
                  url = self._client.format_url(url, **path_format_arguments)
  
                  # Construct parameters
                  query_parameters = {}
                  query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
              else:
                  url = next_link
                  query_parameters = {}
  
              # Construct headers
              header_parameters = {}
              header_parameters['Accept'] = 'application/json'
              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')
  
              # Construct and send request
              request = self._client.get(url, query_parameters, header_parameters)
              return request
  
          def internal_paging(next_link=None):
              request = prepare_request(next_link)
  
              response = self._client.send(request, stream=False, **operation_config)
  
              if response.status_code not in [200]:
                  exp = CloudError(response)
                  exp.request_id = response.headers.get('x-ms-request-id')
                  raise exp
  
              return response
  
          # Deserialize response
          header_dict = None
          if raw:
              header_dict = {}
          deserialized = models.StorageAccountPaged(internal_paging, self._deserialize.dependencies, header_dict)
  
          return deserialized
      list.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Storage/storageAccounts'}
  
      def list_by_resource_group(
              self, resource_group_name, custom_headers=None, raw=False, **operation_config):
          """Lists all the storage accounts available under the given resource
          group. Note that storage keys are not returned; use the ListKeys
          operation for this.
  
          :param resource_group_name: The name of the resource group within the
           user's subscription. The name is case insensitive.
          :type resource_group_name: str
          :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>`.
          :return: An iterator like instance of StorageAccount
          :rtype:
           ~azure.mgmt.storage.v2017_06_01.models.StorageAccountPaged[~azure.mgmt.storage.v2017_06_01.models.StorageAccount]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          def prepare_request(next_link=None):
              if not next_link:
                  # Construct URL
                  url = self.list_by_resource_group.metadata['url']
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
                      'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
                  }
                  url = self._client.format_url(url, **path_format_arguments)
  
                  # Construct parameters
                  query_parameters = {}
                  query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
              else:
                  url = next_link
                  query_parameters = {}
  
              # Construct headers
              header_parameters = {}
              header_parameters['Accept'] = 'application/json'
              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')
  
              # Construct and send request
              request = self._client.get(url, query_parameters, header_parameters)
              return request
  
          def internal_paging(next_link=None):
              request = prepare_request(next_link)
  
              response = self._client.send(request, stream=False, **operation_config)
  
              if response.status_code not in [200]:
                  exp = CloudError(response)
                  exp.request_id = response.headers.get('x-ms-request-id')
                  raise exp
  
              return response
  
          # Deserialize response
          header_dict = None
          if raw:
              header_dict = {}
          deserialized = models.StorageAccountPaged(internal_paging, self._deserialize.dependencies, header_dict)
  
          return deserialized
      list_by_resource_group.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts'}
  
      def list_keys(
              self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):
          """Lists the access keys for the specified storage account.
  
          :param resource_group_name: The name of the resource group within the
           user's subscription. The name is case insensitive.
          :type resource_group_name: str
          :param account_name: The name of the storage account within the
           specified resource group. Storage account names must be between 3 and
           24 characters in length and use numbers and lower-case letters only.
          :type account_name: str
          :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>`.
          :return: StorageAccountListKeysResult or ClientRawResponse if raw=true
          :rtype:
           ~azure.mgmt.storage.v2017_06_01.models.StorageAccountListKeysResult or
           ~msrest.pipeline.ClientRawResponse
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          # Construct URL
          url = self.list_keys.metadata['url']
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'accountName': self._serialize.url("account_name", account_name, 'str', max_length=24, min_length=3),
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          header_parameters['Accept'] = 'application/json'
          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')
  
          # Construct and send request
          request = self._client.post(url, query_parameters, header_parameters)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [200]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('StorageAccountListKeysResult', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
      list_keys.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/listKeys'}
  
      def regenerate_key(
              self, resource_group_name, account_name, key_name, custom_headers=None, raw=False, **operation_config):
          """Regenerates one of the access keys for the specified storage account.
  
          :param resource_group_name: The name of the resource group within the
           user's subscription. The name is case insensitive.
          :type resource_group_name: str
          :param account_name: The name of the storage account within the
           specified resource group. Storage account names must be between 3 and
           24 characters in length and use numbers and lower-case letters only.
          :type account_name: str
          :param key_name: The name of storage keys that want to be regenerated,
           possible values are key1, key2.
          :type key_name: str
          :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>`.
          :return: StorageAccountListKeysResult or ClientRawResponse if raw=true
          :rtype:
           ~azure.mgmt.storage.v2017_06_01.models.StorageAccountListKeysResult or
           ~msrest.pipeline.ClientRawResponse
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          regenerate_key1 = models.StorageAccountRegenerateKeyParameters(key_name=key_name)
  
          # Construct URL
          url = self.regenerate_key.metadata['url']
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'accountName': self._serialize.url("account_name", account_name, 'str', max_length=24, min_length=3),
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          header_parameters['Accept'] = 'application/json'
          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')
  
          # Construct body
          body_content = self._serialize.body(regenerate_key1, 'StorageAccountRegenerateKeyParameters')
  
          # Construct and send request
          request = self._client.post(url, query_parameters, header_parameters, body_content)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [200]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('StorageAccountListKeysResult', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
      regenerate_key.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/regenerateKey'}
  
      def list_account_sas(
              self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, **operation_config):
          """List SAS credentials of a storage account.
  
          :param resource_group_name: The name of the resource group within the
           user's subscription. The name is case insensitive.
          :type resource_group_name: str
          :param account_name: The name of the storage account within the
           specified resource group. Storage account names must be between 3 and
           24 characters in length and use numbers and lower-case letters only.
          :type account_name: str
          :param parameters: The parameters to provide to list SAS credentials
           for the storage account.
          :type parameters:
           ~azure.mgmt.storage.v2017_06_01.models.AccountSasParameters
          :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>`.
          :return: ListAccountSasResponse or ClientRawResponse if raw=true
          :rtype: ~azure.mgmt.storage.v2017_06_01.models.ListAccountSasResponse
           or ~msrest.pipeline.ClientRawResponse
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          # Construct URL
          url = self.list_account_sas.metadata['url']
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'accountName': self._serialize.url("account_name", account_name, 'str', max_length=24, min_length=3),
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          header_parameters['Accept'] = 'application/json'
          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')
  
          # Construct body
          body_content = self._serialize.body(parameters, 'AccountSasParameters')
  
          # Construct and send request
          request = self._client.post(url, query_parameters, header_parameters, body_content)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [200]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('ListAccountSasResponse', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
      list_account_sas.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/ListAccountSas'}
  
      def list_service_sas(
              self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, **operation_config):
          """List service SAS credentials of a specific resource.
  
          :param resource_group_name: The name of the resource group within the
           user's subscription. The name is case insensitive.
          :type resource_group_name: str
          :param account_name: The name of the storage account within the
           specified resource group. Storage account names must be between 3 and
           24 characters in length and use numbers and lower-case letters only.
          :type account_name: str
          :param parameters: The parameters to provide to list service SAS
           credentials.
          :type parameters:
           ~azure.mgmt.storage.v2017_06_01.models.ServiceSasParameters
          :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>`.
          :return: ListServiceSasResponse or ClientRawResponse if raw=true
          :rtype: ~azure.mgmt.storage.v2017_06_01.models.ListServiceSasResponse
           or ~msrest.pipeline.ClientRawResponse
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          # Construct URL
          url = self.list_service_sas.metadata['url']
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'accountName': self._serialize.url("account_name", account_name, 'str', max_length=24, min_length=3),
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          header_parameters['Accept'] = 'application/json'
          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')
  
          # Construct body
          body_content = self._serialize.body(parameters, 'ServiceSasParameters')
  
          # Construct and send request
          request = self._client.post(url, query_parameters, header_parameters, body_content)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [200]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('ListServiceSasResponse', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
      list_service_sas.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/ListServiceSas'}
  