# coding: utf-8

"""
    Python client for GIG based clouds (pc4g)

    RESTful api client to a GIG based cloud.  # noqa: E501

    OpenAPI spec version: v1.0
    
    Generated by: https://github.com/swagger-api/swagger-codegen.git
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from pc4g.api_client import ApiClient


class CustomersApi(object):
    """NOTE: This class is auto generated by the swagger code generator program.

    Do not edit the class manually.
    Ref: https://github.com/swagger-api/swagger-codegen
    """

    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

    def add_cloudspace_anti_affinity_group(self, customer_id, cloudspace_id, spread, group_id, **kwargs):  # noqa: E501
        """add_cloudspace_anti_affinity_group  # noqa: E501

        Add anti-affinity group  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_cloudspace_anti_affinity_group(customer_id, cloudspace_id, spread, group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int spread: Amount of physical nodes to spread vms over. Set to -1 for infinite spread (required)
        :param str group_id: Name of the group (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.add_cloudspace_anti_affinity_group_with_http_info(customer_id, cloudspace_id, spread, group_id, **kwargs)  # noqa: E501
        else:
            (data) = self.add_cloudspace_anti_affinity_group_with_http_info(customer_id, cloudspace_id, spread, group_id, **kwargs)  # noqa: E501
            return data

    def add_cloudspace_anti_affinity_group_with_http_info(self, customer_id, cloudspace_id, spread, group_id, **kwargs):  # noqa: E501
        """add_cloudspace_anti_affinity_group  # noqa: E501

        Add anti-affinity group  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_cloudspace_anti_affinity_group_with_http_info(customer_id, cloudspace_id, spread, group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int spread: Amount of physical nodes to spread vms over. Set to -1 for infinite spread (required)
        :param str group_id: Name of the group (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'spread', 'group_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_cloudspace_anti_affinity_group" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `add_cloudspace_anti_affinity_group`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `add_cloudspace_anti_affinity_group`")  # noqa: E501
        # verify the required parameter 'spread' is set
        if self.api_client.client_side_validation and ('spread' not in params or
                                                       params['spread'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `spread` when calling `add_cloudspace_anti_affinity_group`")  # noqa: E501
        # verify the required parameter 'group_id' is set
        if self.api_client.client_side_validation and ('group_id' not in params or
                                                       params['group_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `group_id` when calling `add_cloudspace_anti_affinity_group`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'spread' in params:
            query_params.append(('spread', params['spread']))  # noqa: E501
        if 'group_id' in params:
            query_params.append(('group_id', params['group_id']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/anti-affinity-groups', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_cloudspace_external_network(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """add_cloudspace_external_network  # noqa: E501

        Add cloudspace external network  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_cloudspace_external_network(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int metric: external network metric(low priority is highest priority)if omitted lowest priority is used
        :param str external_network_ip: optional ip address inside the external network
        :param str external_network_type: optional, default is 'external'. 'cloudspace' connects to an existing network
        :param int external_network_id: optional id to take ip address from.If omited will search for available network
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.add_cloudspace_external_network_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.add_cloudspace_external_network_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def add_cloudspace_external_network_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """add_cloudspace_external_network  # noqa: E501

        Add cloudspace external network  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_cloudspace_external_network_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int metric: external network metric(low priority is highest priority)if omitted lowest priority is used
        :param str external_network_ip: optional ip address inside the external network
        :param str external_network_type: optional, default is 'external'. 'cloudspace' connects to an existing network
        :param int external_network_id: optional id to take ip address from.If omited will search for available network
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'metric', 'external_network_ip', 'external_network_type', 'external_network_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_cloudspace_external_network" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `add_cloudspace_external_network`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `add_cloudspace_external_network`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'metric' in params:
            query_params.append(('metric', params['metric']))  # noqa: E501
        if 'external_network_ip' in params:
            query_params.append(('external_network_ip', params['external_network_ip']))  # noqa: E501
        if 'external_network_type' in params:
            query_params.append(('external_network_type', params['external_network_type']))  # noqa: E501
        if 'external_network_id' in params:
            query_params.append(('external_network_id', params['external_network_id']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/external-network', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_cloudspace_network_route(self, customer_id, cloudspace_id, destination, gateway, **kwargs):  # noqa: E501
        """add_cloudspace_network_route  # noqa: E501

        Add extra route to network  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_cloudspace_network_route(customer_id, cloudspace_id, destination, gateway, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str destination: Destination network to route (required)
        :param str gateway: Gateway to route desination over (required)
        :param int table: routing table to add route to
        :param int metric: external network metric(low priority is highest priority) if omitted lowest priority is used
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.add_cloudspace_network_route_with_http_info(customer_id, cloudspace_id, destination, gateway, **kwargs)  # noqa: E501
        else:
            (data) = self.add_cloudspace_network_route_with_http_info(customer_id, cloudspace_id, destination, gateway, **kwargs)  # noqa: E501
            return data

    def add_cloudspace_network_route_with_http_info(self, customer_id, cloudspace_id, destination, gateway, **kwargs):  # noqa: E501
        """add_cloudspace_network_route  # noqa: E501

        Add extra route to network  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_cloudspace_network_route_with_http_info(customer_id, cloudspace_id, destination, gateway, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str destination: Destination network to route (required)
        :param str gateway: Gateway to route desination over (required)
        :param int table: routing table to add route to
        :param int metric: external network metric(low priority is highest priority) if omitted lowest priority is used
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'destination', 'gateway', 'table', 'metric', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_cloudspace_network_route" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `add_cloudspace_network_route`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `add_cloudspace_network_route`")  # noqa: E501
        # verify the required parameter 'destination' is set
        if self.api_client.client_side_validation and ('destination' not in params or
                                                       params['destination'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `destination` when calling `add_cloudspace_network_route`")  # noqa: E501
        # verify the required parameter 'gateway' is set
        if self.api_client.client_side_validation and ('gateway' not in params or
                                                       params['gateway'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `gateway` when calling `add_cloudspace_network_route`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'table' in params:
            query_params.append(('table', params['table']))  # noqa: E501
        if 'metric' in params:
            query_params.append(('metric', params['metric']))  # noqa: E501
        if 'destination' in params:
            query_params.append(('destination', params['destination']))  # noqa: E501
        if 'gateway' in params:
            query_params.append(('gateway', params['gateway']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/routes', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_customer_location(self, customer_id, payload, **kwargs):  # noqa: E501
        """add_customer_location  # noqa: E501

        Add location for Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_customer_location(customer_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param LocationPricing payload: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.add_customer_location_with_http_info(customer_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.add_customer_location_with_http_info(customer_id, payload, **kwargs)  # noqa: E501
            return data

    def add_customer_location_with_http_info(self, customer_id, payload, **kwargs):  # noqa: E501
        """add_customer_location  # noqa: E501

        Add location for Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_customer_location_with_http_info(customer_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param LocationPricing payload: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'payload']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_customer_location" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `add_customer_location`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `add_customer_location`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_remote_cloudspace(self, customer_id, cloudspace_id, connected_cloudspace_id, **kwargs):  # noqa: E501
        """add_remote_cloudspace  # noqa: E501

        Add remote connection to cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_remote_cloudspace(customer_id, cloudspace_id, connected_cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str connected_cloudspace_id: Cloudspace to connect to (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.add_remote_cloudspace_with_http_info(customer_id, cloudspace_id, connected_cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.add_remote_cloudspace_with_http_info(customer_id, cloudspace_id, connected_cloudspace_id, **kwargs)  # noqa: E501
            return data

    def add_remote_cloudspace_with_http_info(self, customer_id, cloudspace_id, connected_cloudspace_id, **kwargs):  # noqa: E501
        """add_remote_cloudspace  # noqa: E501

        Add remote connection to cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_remote_cloudspace_with_http_info(customer_id, cloudspace_id, connected_cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str connected_cloudspace_id: Cloudspace to connect to (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'connected_cloudspace_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_remote_cloudspace" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `add_remote_cloudspace`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `add_remote_cloudspace`")  # noqa: E501
        # verify the required parameter 'connected_cloudspace_id' is set
        if self.api_client.client_side_validation and ('connected_cloudspace_id' not in params or
                                                       params['connected_cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `connected_cloudspace_id` when calling `add_remote_cloudspace`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'connected_cloudspace_id' in params:
            query_params.append(('connected_cloudspace_id', params['connected_cloudspace_id']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/connected-cloudspaces', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_support_access(self, customer_id, **kwargs):  # noqa: E501
        """add_support_access  # noqa: E501

        add support organization access  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_support_access(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.add_support_access_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.add_support_access_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def add_support_access_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """add_support_access  # noqa: E501

        add support organization access  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_support_access_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_support_access" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `add_support_access`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/support-access', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def add_virtual_machine_anti_affinity_groups(self, customer_id, cloudspace_id, group_id, vm_id, **kwargs):  # noqa: E501
        """add_virtual_machine_anti_affinity_groups  # noqa: E501

        Add virtual machine anti-affinity group  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_virtual_machine_anti_affinity_groups(customer_id, cloudspace_id, group_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str group_id: (required)
        :param int vm_id: VM ID (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.add_virtual_machine_anti_affinity_groups_with_http_info(customer_id, cloudspace_id, group_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.add_virtual_machine_anti_affinity_groups_with_http_info(customer_id, cloudspace_id, group_id, vm_id, **kwargs)  # noqa: E501
            return data

    def add_virtual_machine_anti_affinity_groups_with_http_info(self, customer_id, cloudspace_id, group_id, vm_id, **kwargs):  # noqa: E501
        """add_virtual_machine_anti_affinity_groups  # noqa: E501

        Add virtual machine anti-affinity group  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_virtual_machine_anti_affinity_groups_with_http_info(customer_id, cloudspace_id, group_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str group_id: (required)
        :param int vm_id: VM ID (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'group_id', 'vm_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_virtual_machine_anti_affinity_groups" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `add_virtual_machine_anti_affinity_groups`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `add_virtual_machine_anti_affinity_groups`")  # noqa: E501
        # verify the required parameter 'group_id' is set
        if self.api_client.client_side_validation and ('group_id' not in params or
                                                       params['group_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `group_id` when calling `add_virtual_machine_anti_affinity_groups`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `add_virtual_machine_anti_affinity_groups`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'group_id' in params:
            path_params['group_id'] = params['group_id']  # noqa: E501

        query_params = []
        if 'vm_id' in params:
            query_params.append(('vm_id', params['vm_id']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/anti-affinity-groups/{group_id}/vms', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def attach_disk_virtual_machine(self, customer_id, cloudspace_id, vm_id, disk_id, **kwargs):  # noqa: E501
        """attach_disk_virtual_machine  # noqa: E501

        Attach a disk on virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.attach_disk_virtual_machine(customer_id, cloudspace_id, vm_id, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int disk_id: Disk ID (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.attach_disk_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, disk_id, **kwargs)  # noqa: E501
        else:
            (data) = self.attach_disk_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, disk_id, **kwargs)  # noqa: E501
            return data

    def attach_disk_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, disk_id, **kwargs):  # noqa: E501
        """attach_disk_virtual_machine  # noqa: E501

        Attach a disk on virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.attach_disk_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int disk_id: Disk ID (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'disk_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method attach_disk_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `attach_disk_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `attach_disk_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `attach_disk_virtual_machine`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `attach_disk_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'disk_id' in params:
            query_params.append(('disk_id', params['disk_id']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/disks', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def attach_external_networks_virtual_machine(self, customer_id, cloudspace_id, vm_id, external_network_id, **kwargs):  # noqa: E501
        """attach_external_networks_virtual_machine  # noqa: E501

        Attach external network (NIC) to virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.attach_external_networks_virtual_machine(customer_id, cloudspace_id, vm_id, external_network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int external_network_id: External network ID (required)
        :param str external_network_ip: IP Address to reserve for this Machine's NIC
        :param str model: the new NIC model
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.attach_external_networks_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, external_network_id, **kwargs)  # noqa: E501
        else:
            (data) = self.attach_external_networks_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, external_network_id, **kwargs)  # noqa: E501
            return data

    def attach_external_networks_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, external_network_id, **kwargs):  # noqa: E501
        """attach_external_networks_virtual_machine  # noqa: E501

        Attach external network (NIC) to virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.attach_external_networks_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, external_network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int external_network_id: External network ID (required)
        :param str external_network_ip: IP Address to reserve for this Machine's NIC
        :param str model: the new NIC model
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'external_network_id', 'external_network_ip', 'model', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method attach_external_networks_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `attach_external_networks_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `attach_external_networks_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `attach_external_networks_virtual_machine`")  # noqa: E501
        # verify the required parameter 'external_network_id' is set
        if self.api_client.client_side_validation and ('external_network_id' not in params or
                                                       params['external_network_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `external_network_id` when calling `attach_external_networks_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'external_network_id' in params:
            query_params.append(('external_network_id', params['external_network_id']))  # noqa: E501
        if 'external_network_ip' in params:
            query_params.append(('external_network_ip', params['external_network_ip']))  # noqa: E501
        if 'model' in params:
            query_params.append(('model', params['model']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/external-nics', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def attach_virtual_machine_cdrom(self, customer_id, cloudspace_id, vm_id, cdrom_id, **kwargs):  # noqa: E501
        """attach_virtual_machine_cdrom  # noqa: E501

        Attach CDROM image to Virtual Machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.attach_virtual_machine_cdrom(customer_id, cloudspace_id, vm_id, cdrom_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int cdrom_id: ID of the CD-ROM image (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.attach_virtual_machine_cdrom_with_http_info(customer_id, cloudspace_id, vm_id, cdrom_id, **kwargs)  # noqa: E501
        else:
            (data) = self.attach_virtual_machine_cdrom_with_http_info(customer_id, cloudspace_id, vm_id, cdrom_id, **kwargs)  # noqa: E501
            return data

    def attach_virtual_machine_cdrom_with_http_info(self, customer_id, cloudspace_id, vm_id, cdrom_id, **kwargs):  # noqa: E501
        """attach_virtual_machine_cdrom  # noqa: E501

        Attach CDROM image to Virtual Machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.attach_virtual_machine_cdrom_with_http_info(customer_id, cloudspace_id, vm_id, cdrom_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int cdrom_id: ID of the CD-ROM image (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'cdrom_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method attach_virtual_machine_cdrom" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `attach_virtual_machine_cdrom`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `attach_virtual_machine_cdrom`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `attach_virtual_machine_cdrom`")  # noqa: E501
        # verify the required parameter 'cdrom_id' is set
        if self.api_client.client_side_validation and ('cdrom_id' not in params or
                                                       params['cdrom_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cdrom_id` when calling `attach_virtual_machine_cdrom`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'cdrom_id' in params:
            query_params.append(('cdrom_id', params['cdrom_id']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/cdrom-images', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def change_agent_status(self, customer_id, cloudspace_id, vm_id, payload, **kwargs):  # noqa: E501
        """change_agent_status  # noqa: E501

        Enable/Disable virtual machine agent  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.change_agent_status(customer_id, cloudspace_id, vm_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param ChangeAgentStatus payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.change_agent_status_with_http_info(customer_id, cloudspace_id, vm_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.change_agent_status_with_http_info(customer_id, cloudspace_id, vm_id, payload, **kwargs)  # noqa: E501
            return data

    def change_agent_status_with_http_info(self, customer_id, cloudspace_id, vm_id, payload, **kwargs):  # noqa: E501
        """change_agent_status  # noqa: E501

        Enable/Disable virtual machine agent  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.change_agent_status_with_http_info(customer_id, cloudspace_id, vm_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param ChangeAgentStatus payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method change_agent_status" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `change_agent_status`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `change_agent_status`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `change_agent_status`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `change_agent_status`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/agent', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def clone_disk_snapshot(self, customer_id, location, disk_id, snapshot_id, name, **kwargs):  # noqa: E501
        """clone_disk_snapshot  # noqa: E501

        Clone Disk snapshot  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.clone_disk_snapshot(customer_id, location, disk_id, snapshot_id, name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str snapshot_id: (required)
        :param str name: New disk name (required)
        :param str description: New disk Description
        :param bool all_vm_disks: Create clones of all snapshots that were created in the same action
        :param str x_fields: An optional fields mask
        :return: CloneDiskSnapshot
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.clone_disk_snapshot_with_http_info(customer_id, location, disk_id, snapshot_id, name, **kwargs)  # noqa: E501
        else:
            (data) = self.clone_disk_snapshot_with_http_info(customer_id, location, disk_id, snapshot_id, name, **kwargs)  # noqa: E501
            return data

    def clone_disk_snapshot_with_http_info(self, customer_id, location, disk_id, snapshot_id, name, **kwargs):  # noqa: E501
        """clone_disk_snapshot  # noqa: E501

        Clone Disk snapshot  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.clone_disk_snapshot_with_http_info(customer_id, location, disk_id, snapshot_id, name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str snapshot_id: (required)
        :param str name: New disk name (required)
        :param str description: New disk Description
        :param bool all_vm_disks: Create clones of all snapshots that were created in the same action
        :param str x_fields: An optional fields mask
        :return: CloneDiskSnapshot
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'snapshot_id', 'name', 'description', 'all_vm_disks', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method clone_disk_snapshot" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `clone_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `clone_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `clone_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'snapshot_id' is set
        if self.api_client.client_side_validation and ('snapshot_id' not in params or
                                                       params['snapshot_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `snapshot_id` when calling `clone_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'name' is set
        if self.api_client.client_side_validation and ('name' not in params or
                                                       params['name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `name` when calling `clone_disk_snapshot`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501
        if 'snapshot_id' in params:
            path_params['snapshot_id'] = params['snapshot_id']  # noqa: E501

        query_params = []
        if 'name' in params:
            query_params.append(('name', params['name']))  # noqa: E501
        if 'description' in params:
            query_params.append(('description', params['description']))  # noqa: E501
        if 'all_vm_disks' in params:
            query_params.append(('all_vm_disks', params['all_vm_disks']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/snapshots/{snapshot_id}/clone', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CloneDiskSnapshot',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def compliance_scan(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """compliance_scan  # noqa: E501

        execute octopus scanner in the virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.compliance_scan(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.compliance_scan_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.compliance_scan_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def compliance_scan_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """compliance_scan  # noqa: E501

        execute octopus scanner in the virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.compliance_scan_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method compliance_scan" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `compliance_scan`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `compliance_scan`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `compliance_scan`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/compliance-scan', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def connect_objectspace(self, customer_id, cloudspace_id, objectspace_id, **kwargs):  # noqa: E501
        """connect_objectspace  # noqa: E501

        Connecting objectspace to a cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.connect_objectspace(customer_id, cloudspace_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str objectspace_id: The objectspace id to be added to the cloudspace (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.connect_objectspace_with_http_info(customer_id, cloudspace_id, objectspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.connect_objectspace_with_http_info(customer_id, cloudspace_id, objectspace_id, **kwargs)  # noqa: E501
            return data

    def connect_objectspace_with_http_info(self, customer_id, cloudspace_id, objectspace_id, **kwargs):  # noqa: E501
        """connect_objectspace  # noqa: E501

        Connecting objectspace to a cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.connect_objectspace_with_http_info(customer_id, cloudspace_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str objectspace_id: The objectspace id to be added to the cloudspace (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'objectspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method connect_objectspace" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `connect_objectspace`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `connect_objectspace`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `connect_objectspace`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'objectspace_id' in params:
            query_params.append(('objectspace_id', params['objectspace_id']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/objectspaces', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_bucket(self, customer_id, objectspace_id, bucket_id, **kwargs):  # noqa: E501
        """create_bucket  # noqa: E501

        Create a bucket  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_bucket(customer_id, objectspace_id, bucket_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str bucket_id: (required)
        :param int limit: limit of IOPS for the bucket
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_bucket_with_http_info(customer_id, objectspace_id, bucket_id, **kwargs)  # noqa: E501
        else:
            (data) = self.create_bucket_with_http_info(customer_id, objectspace_id, bucket_id, **kwargs)  # noqa: E501
            return data

    def create_bucket_with_http_info(self, customer_id, objectspace_id, bucket_id, **kwargs):  # noqa: E501
        """create_bucket  # noqa: E501

        Create a bucket  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_bucket_with_http_info(customer_id, objectspace_id, bucket_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str bucket_id: (required)
        :param int limit: limit of IOPS for the bucket
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'objectspace_id', 'bucket_id', 'limit', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_bucket" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_bucket`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `create_bucket`")  # noqa: E501
        # verify the required parameter 'bucket_id' is set
        if self.api_client.client_side_validation and ('bucket_id' not in params or
                                                       params['bucket_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `bucket_id` when calling `create_bucket`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'objectspace_id' in params:
            path_params['objectspace_id'] = params['objectspace_id']  # noqa: E501
        if 'bucket_id' in params:
            path_params['bucket_id'] = params['bucket_id']  # noqa: E501

        query_params = []
        if 'limit' in params:
            query_params.append(('limit', params['limit']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces/{objectspace_id}/buckets/{bucket_id}', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_cloudspace(self, customer_id, payload, **kwargs):  # noqa: E501
        """create_cloudspace  # noqa: E501

        Create cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_cloudspace(customer_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param CreateCloudspace payload: (required)
        :param str x_fields: An optional fields mask
        :return: CloudspaceIDModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_cloudspace_with_http_info(customer_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.create_cloudspace_with_http_info(customer_id, payload, **kwargs)  # noqa: E501
            return data

    def create_cloudspace_with_http_info(self, customer_id, payload, **kwargs):  # noqa: E501
        """create_cloudspace  # noqa: E501

        Create cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_cloudspace_with_http_info(customer_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param CreateCloudspace payload: (required)
        :param str x_fields: An optional fields mask
        :return: CloudspaceIDModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_cloudspace" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_cloudspace`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `create_cloudspace`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CloudspaceIDModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_cloudspace_note(self, customer_id, cloudspace_id, payload, **kwargs):  # noqa: E501
        """create_cloudspace_note  # noqa: E501

        Create cloudspace note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_cloudspace_note(customer_id, cloudspace_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_cloudspace_note_with_http_info(customer_id, cloudspace_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.create_cloudspace_note_with_http_info(customer_id, cloudspace_id, payload, **kwargs)  # noqa: E501
            return data

    def create_cloudspace_note_with_http_info(self, customer_id, cloudspace_id, payload, **kwargs):  # noqa: E501
        """create_cloudspace_note  # noqa: E501

        Create cloudspace note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_cloudspace_note_with_http_info(customer_id, cloudspace_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_cloudspace_note" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_cloudspace_note`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `create_cloudspace_note`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `create_cloudspace_note`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/notes', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_customer(self, payload, **kwargs):  # noqa: E501
        """create_customer  # noqa: E501

        Add new customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_customer(payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CustomerCreate payload: (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_customer_with_http_info(payload, **kwargs)  # noqa: E501
        else:
            (data) = self.create_customer_with_http_info(payload, **kwargs)  # noqa: E501
            return data

    def create_customer_with_http_info(self, payload, **kwargs):  # noqa: E501
        """create_customer  # noqa: E501

        Add new customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_customer_with_http_info(payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CustomerCreate payload: (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['payload']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_customer" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `create_customer`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_customer_cdrom_image(self, customer_id, location, name, url, os_type, os_name, **kwargs):  # noqa: E501
        """create_customer_cdrom_image  # noqa: E501

        Create CDROM image  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_customer_cdrom_image(customer_id, location, name, url, os_type, os_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str name: CD-ROM Name (required)
        :param str url: CD-ROM image URL (required)
        :param str os_type: OS Type (required)
        :param str os_name: Specific name of the Operating system (required)
        :param str x_fields: An optional fields mask
        :return: CDROMIdModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_customer_cdrom_image_with_http_info(customer_id, location, name, url, os_type, os_name, **kwargs)  # noqa: E501
        else:
            (data) = self.create_customer_cdrom_image_with_http_info(customer_id, location, name, url, os_type, os_name, **kwargs)  # noqa: E501
            return data

    def create_customer_cdrom_image_with_http_info(self, customer_id, location, name, url, os_type, os_name, **kwargs):  # noqa: E501
        """create_customer_cdrom_image  # noqa: E501

        Create CDROM image  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_customer_cdrom_image_with_http_info(customer_id, location, name, url, os_type, os_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str name: CD-ROM Name (required)
        :param str url: CD-ROM image URL (required)
        :param str os_type: OS Type (required)
        :param str os_name: Specific name of the Operating system (required)
        :param str x_fields: An optional fields mask
        :return: CDROMIdModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'name', 'url', 'os_type', 'os_name', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_customer_cdrom_image" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_customer_cdrom_image`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `create_customer_cdrom_image`")  # noqa: E501
        # verify the required parameter 'name' is set
        if self.api_client.client_side_validation and ('name' not in params or
                                                       params['name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `name` when calling `create_customer_cdrom_image`")  # noqa: E501
        # verify the required parameter 'url' is set
        if self.api_client.client_side_validation and ('url' not in params or
                                                       params['url'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `url` when calling `create_customer_cdrom_image`")  # noqa: E501
        # verify the required parameter 'os_type' is set
        if self.api_client.client_side_validation and ('os_type' not in params or
                                                       params['os_type'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `os_type` when calling `create_customer_cdrom_image`")  # noqa: E501
        # verify the required parameter 'os_name' is set
        if self.api_client.client_side_validation and ('os_name' not in params or
                                                       params['os_name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `os_name` when calling `create_customer_cdrom_image`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501

        query_params = []
        if 'name' in params:
            query_params.append(('name', params['name']))  # noqa: E501
        if 'url' in params:
            query_params.append(('url', params['url']))  # noqa: E501
        if 'os_type' in params:
            query_params.append(('os_type', params['os_type']))  # noqa: E501
        if 'os_name' in params:
            query_params.append(('os_name', params['os_name']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/cdrom-images', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CDROMIdModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_customer_certificate(self, customer_id, payload, **kwargs):  # noqa: E501
        """create_customer_certificate  # noqa: E501

        Create certificate  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_customer_certificate(customer_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param CreateCustomerCertificate payload: (required)
        :param str x_fields: An optional fields mask
        :return: Certificates
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_customer_certificate_with_http_info(customer_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.create_customer_certificate_with_http_info(customer_id, payload, **kwargs)  # noqa: E501
            return data

    def create_customer_certificate_with_http_info(self, customer_id, payload, **kwargs):  # noqa: E501
        """create_customer_certificate  # noqa: E501

        Create certificate  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_customer_certificate_with_http_info(customer_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param CreateCustomerCertificate payload: (required)
        :param str x_fields: An optional fields mask
        :return: Certificates
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_customer_certificate" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_customer_certificate`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `create_customer_certificate`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/certificates/ssl', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Certificates',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_customer_image(self, customer_id, location, name, url, memory, boot_disk_size, boot_type, os_name, os_type, **kwargs):  # noqa: E501
        """create_customer_image  # noqa: E501

        Create customer Image  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_customer_image(customer_id, location, name, url, memory, boot_disk_size, boot_type, os_name, os_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str name: Image Name (required)
        :param str url: Image URL (required)
        :param int memory: Minimum required memory for this image (required)
        :param int boot_disk_size: Minimum Boot disk size (required)
        :param str boot_type: Boot Type (required)
        :param str os_name: Specific name of the Operating system (required)
        :param str os_type: OS Type (required)
        :param bool add_memory: This image supports hot memory addition
        :param bool add_vcpu: This image supports hot VCPU addition
        :param bool remove_vcpu: This image supports hot VCPU removal
        :param bool add_disk: This image supports hot disk addition
        :param bool remove_disk: This image supports hot disk removal
        :param bool add_nic: This image supports hot NIC addition
        :param bool remove_nic: This image supports hot NIC removal
        :param str username: Optional os username for the image
        :param str password: Optional os password for the image
        :param str user_data: Userdata about image such as product key
        :param str tags: tags for the image
        :param str md5_sum: optional md5sum to check validity of the image
        :param str x_fields: An optional fields mask
        :return: ImageID
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_customer_image_with_http_info(customer_id, location, name, url, memory, boot_disk_size, boot_type, os_name, os_type, **kwargs)  # noqa: E501
        else:
            (data) = self.create_customer_image_with_http_info(customer_id, location, name, url, memory, boot_disk_size, boot_type, os_name, os_type, **kwargs)  # noqa: E501
            return data

    def create_customer_image_with_http_info(self, customer_id, location, name, url, memory, boot_disk_size, boot_type, os_name, os_type, **kwargs):  # noqa: E501
        """create_customer_image  # noqa: E501

        Create customer Image  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_customer_image_with_http_info(customer_id, location, name, url, memory, boot_disk_size, boot_type, os_name, os_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str name: Image Name (required)
        :param str url: Image URL (required)
        :param int memory: Minimum required memory for this image (required)
        :param int boot_disk_size: Minimum Boot disk size (required)
        :param str boot_type: Boot Type (required)
        :param str os_name: Specific name of the Operating system (required)
        :param str os_type: OS Type (required)
        :param bool add_memory: This image supports hot memory addition
        :param bool add_vcpu: This image supports hot VCPU addition
        :param bool remove_vcpu: This image supports hot VCPU removal
        :param bool add_disk: This image supports hot disk addition
        :param bool remove_disk: This image supports hot disk removal
        :param bool add_nic: This image supports hot NIC addition
        :param bool remove_nic: This image supports hot NIC removal
        :param str username: Optional os username for the image
        :param str password: Optional os password for the image
        :param str user_data: Userdata about image such as product key
        :param str tags: tags for the image
        :param str md5_sum: optional md5sum to check validity of the image
        :param str x_fields: An optional fields mask
        :return: ImageID
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'name', 'url', 'memory', 'boot_disk_size', 'boot_type', 'os_name', 'os_type', 'add_memory', 'add_vcpu', 'remove_vcpu', 'add_disk', 'remove_disk', 'add_nic', 'remove_nic', 'username', 'password', 'user_data', 'tags', 'md5_sum', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_customer_image" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_customer_image`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `create_customer_image`")  # noqa: E501
        # verify the required parameter 'name' is set
        if self.api_client.client_side_validation and ('name' not in params or
                                                       params['name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `name` when calling `create_customer_image`")  # noqa: E501
        # verify the required parameter 'url' is set
        if self.api_client.client_side_validation and ('url' not in params or
                                                       params['url'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `url` when calling `create_customer_image`")  # noqa: E501
        # verify the required parameter 'memory' is set
        if self.api_client.client_side_validation and ('memory' not in params or
                                                       params['memory'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `memory` when calling `create_customer_image`")  # noqa: E501
        # verify the required parameter 'boot_disk_size' is set
        if self.api_client.client_side_validation and ('boot_disk_size' not in params or
                                                       params['boot_disk_size'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `boot_disk_size` when calling `create_customer_image`")  # noqa: E501
        # verify the required parameter 'boot_type' is set
        if self.api_client.client_side_validation and ('boot_type' not in params or
                                                       params['boot_type'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `boot_type` when calling `create_customer_image`")  # noqa: E501
        # verify the required parameter 'os_name' is set
        if self.api_client.client_side_validation and ('os_name' not in params or
                                                       params['os_name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `os_name` when calling `create_customer_image`")  # noqa: E501
        # verify the required parameter 'os_type' is set
        if self.api_client.client_side_validation and ('os_type' not in params or
                                                       params['os_type'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `os_type` when calling `create_customer_image`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501

        query_params = []
        if 'name' in params:
            query_params.append(('name', params['name']))  # noqa: E501
        if 'url' in params:
            query_params.append(('url', params['url']))  # noqa: E501
        if 'memory' in params:
            query_params.append(('memory', params['memory']))  # noqa: E501
        if 'boot_disk_size' in params:
            query_params.append(('boot_disk_size', params['boot_disk_size']))  # noqa: E501
        if 'add_memory' in params:
            query_params.append(('add_memory', params['add_memory']))  # noqa: E501
        if 'add_vcpu' in params:
            query_params.append(('add_vcpu', params['add_vcpu']))  # noqa: E501
        if 'remove_vcpu' in params:
            query_params.append(('remove_vcpu', params['remove_vcpu']))  # noqa: E501
        if 'add_disk' in params:
            query_params.append(('add_disk', params['add_disk']))  # noqa: E501
        if 'remove_disk' in params:
            query_params.append(('remove_disk', params['remove_disk']))  # noqa: E501
        if 'add_nic' in params:
            query_params.append(('add_nic', params['add_nic']))  # noqa: E501
        if 'remove_nic' in params:
            query_params.append(('remove_nic', params['remove_nic']))  # noqa: E501
        if 'username' in params:
            query_params.append(('username', params['username']))  # noqa: E501
        if 'password' in params:
            query_params.append(('password', params['password']))  # noqa: E501
        if 'user_data' in params:
            query_params.append(('user_data', params['user_data']))  # noqa: E501
        if 'tags' in params:
            query_params.append(('tags', params['tags']))  # noqa: E501
        if 'md5_sum' in params:
            query_params.append(('md5_sum', params['md5_sum']))  # noqa: E501
        if 'boot_type' in params:
            query_params.append(('boot_type', params['boot_type']))  # noqa: E501
        if 'os_name' in params:
            query_params.append(('os_name', params['os_name']))  # noqa: E501
        if 'os_type' in params:
            query_params.append(('os_type', params['os_type']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/vm-images', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ImageID',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_disk(self, customer_id, location, disk_name, description, disk_size, **kwargs):  # noqa: E501
        """create_disk  # noqa: E501

        Create disk  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_disk(customer_id, location, disk_name, description, disk_size, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str disk_name: Name of disk to create (required)
        :param str description: Disk description (required)
        :param int disk_size: Disk size in GB (required)
        :param int iops: Disk IOPS
        :param str disk_type: Disk Type
        :param str vm_id: (Optional) VM ID of Virtual Machine to attach to
        :param str x_fields: An optional fields mask
        :return: DiskIdModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_disk_with_http_info(customer_id, location, disk_name, description, disk_size, **kwargs)  # noqa: E501
        else:
            (data) = self.create_disk_with_http_info(customer_id, location, disk_name, description, disk_size, **kwargs)  # noqa: E501
            return data

    def create_disk_with_http_info(self, customer_id, location, disk_name, description, disk_size, **kwargs):  # noqa: E501
        """create_disk  # noqa: E501

        Create disk  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_disk_with_http_info(customer_id, location, disk_name, description, disk_size, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str disk_name: Name of disk to create (required)
        :param str description: Disk description (required)
        :param int disk_size: Disk size in GB (required)
        :param int iops: Disk IOPS
        :param str disk_type: Disk Type
        :param str vm_id: (Optional) VM ID of Virtual Machine to attach to
        :param str x_fields: An optional fields mask
        :return: DiskIdModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_name', 'description', 'disk_size', 'iops', 'disk_type', 'vm_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_disk" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_disk`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `create_disk`")  # noqa: E501
        # verify the required parameter 'disk_name' is set
        if self.api_client.client_side_validation and ('disk_name' not in params or
                                                       params['disk_name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_name` when calling `create_disk`")  # noqa: E501
        # verify the required parameter 'description' is set
        if self.api_client.client_side_validation and ('description' not in params or
                                                       params['description'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `description` when calling `create_disk`")  # noqa: E501
        # verify the required parameter 'disk_size' is set
        if self.api_client.client_side_validation and ('disk_size' not in params or
                                                       params['disk_size'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_size` when calling `create_disk`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501

        query_params = []
        if 'disk_name' in params:
            query_params.append(('disk_name', params['disk_name']))  # noqa: E501
        if 'description' in params:
            query_params.append(('description', params['description']))  # noqa: E501
        if 'disk_size' in params:
            query_params.append(('disk_size', params['disk_size']))  # noqa: E501
        if 'iops' in params:
            query_params.append(('iops', params['iops']))  # noqa: E501
        if 'disk_type' in params:
            query_params.append(('disk_type', params['disk_type']))  # noqa: E501
        if 'vm_id' in params:
            query_params.append(('vm_id', params['vm_id']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DiskIdModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_disk_note(self, customer_id, location, disk_id, payload, **kwargs):  # noqa: E501
        """create_disk_note  # noqa: E501

        Create disk note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_disk_note(customer_id, location, disk_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_disk_note_with_http_info(customer_id, location, disk_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.create_disk_note_with_http_info(customer_id, location, disk_id, payload, **kwargs)  # noqa: E501
            return data

    def create_disk_note_with_http_info(self, customer_id, location, disk_id, payload, **kwargs):  # noqa: E501
        """create_disk_note  # noqa: E501

        Create disk note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_disk_note_with_http_info(customer_id, location, disk_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_disk_note" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_disk_note`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `create_disk_note`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `create_disk_note`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `create_disk_note`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/notes', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_objectspace(self, customer_id, name, location, **kwargs):  # noqa: E501
        """create_objectspace  # noqa: E501

        Create an object space  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_objectspace(customer_id, name, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str name: Name of the Object Space (required)
        :param str location: The location of the objectspace (required)
        :param str x_fields: An optional fields mask
        :return: CreateObjectspaceModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_objectspace_with_http_info(customer_id, name, location, **kwargs)  # noqa: E501
        else:
            (data) = self.create_objectspace_with_http_info(customer_id, name, location, **kwargs)  # noqa: E501
            return data

    def create_objectspace_with_http_info(self, customer_id, name, location, **kwargs):  # noqa: E501
        """create_objectspace  # noqa: E501

        Create an object space  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_objectspace_with_http_info(customer_id, name, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str name: Name of the Object Space (required)
        :param str location: The location of the objectspace (required)
        :param str x_fields: An optional fields mask
        :return: CreateObjectspaceModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'name', 'location', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_objectspace" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_objectspace`")  # noqa: E501
        # verify the required parameter 'name' is set
        if self.api_client.client_side_validation and ('name' not in params or
                                                       params['name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `name` when calling `create_objectspace`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `create_objectspace`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []
        if 'name' in params:
            query_params.append(('name', params['name']))  # noqa: E501
        if 'location' in params:
            query_params.append(('location', params['location']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateObjectspaceModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_objectspace_note(self, customer_id, objectspace_id, payload, **kwargs):  # noqa: E501
        """create_objectspace_note  # noqa: E501

        Create objectspace note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_objectspace_note(customer_id, objectspace_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_objectspace_note_with_http_info(customer_id, objectspace_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.create_objectspace_note_with_http_info(customer_id, objectspace_id, payload, **kwargs)  # noqa: E501
            return data

    def create_objectspace_note_with_http_info(self, customer_id, objectspace_id, payload, **kwargs):  # noqa: E501
        """create_objectspace_note  # noqa: E501

        Create objectspace note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_objectspace_note_with_http_info(customer_id, objectspace_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'objectspace_id', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_objectspace_note" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_objectspace_note`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `create_objectspace_note`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `create_objectspace_note`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'objectspace_id' in params:
            path_params['objectspace_id'] = params['objectspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces/{objectspace_id}/notes', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_portforward(self, customer_id, cloudspace_id, local_port, public_port, protocol, **kwargs):  # noqa: E501
        """create_portforward  # noqa: E501

        Create cloudspace port forward  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_portforward(customer_id, cloudspace_id, local_port, public_port, protocol, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int local_port: Local port (required)
        :param int public_port: Public port (required)
        :param str protocol: Protocol for port forwarding (required)
        :param int vm_id: Virtual Machine ID
        :param int nested_cs_id: Nested Cloudspace ID
        :param str x_fields: An optional fields mask
        :return: PortforwardID
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_portforward_with_http_info(customer_id, cloudspace_id, local_port, public_port, protocol, **kwargs)  # noqa: E501
        else:
            (data) = self.create_portforward_with_http_info(customer_id, cloudspace_id, local_port, public_port, protocol, **kwargs)  # noqa: E501
            return data

    def create_portforward_with_http_info(self, customer_id, cloudspace_id, local_port, public_port, protocol, **kwargs):  # noqa: E501
        """create_portforward  # noqa: E501

        Create cloudspace port forward  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_portforward_with_http_info(customer_id, cloudspace_id, local_port, public_port, protocol, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int local_port: Local port (required)
        :param int public_port: Public port (required)
        :param str protocol: Protocol for port forwarding (required)
        :param int vm_id: Virtual Machine ID
        :param int nested_cs_id: Nested Cloudspace ID
        :param str x_fields: An optional fields mask
        :return: PortforwardID
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'local_port', 'public_port', 'protocol', 'vm_id', 'nested_cs_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_portforward" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_portforward`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `create_portforward`")  # noqa: E501
        # verify the required parameter 'local_port' is set
        if self.api_client.client_side_validation and ('local_port' not in params or
                                                       params['local_port'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `local_port` when calling `create_portforward`")  # noqa: E501
        # verify the required parameter 'public_port' is set
        if self.api_client.client_side_validation and ('public_port' not in params or
                                                       params['public_port'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `public_port` when calling `create_portforward`")  # noqa: E501
        # verify the required parameter 'protocol' is set
        if self.api_client.client_side_validation and ('protocol' not in params or
                                                       params['protocol'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `protocol` when calling `create_portforward`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'local_port' in params:
            query_params.append(('local_port', params['local_port']))  # noqa: E501
        if 'public_port' in params:
            query_params.append(('public_port', params['public_port']))  # noqa: E501
        if 'vm_id' in params:
            query_params.append(('vm_id', params['vm_id']))  # noqa: E501
        if 'nested_cs_id' in params:
            query_params.append(('nested_cs_id', params['nested_cs_id']))  # noqa: E501
        if 'protocol' in params:
            query_params.append(('protocol', params['protocol']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/portforwards', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PortforwardID',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_role(self, customer_id, payload, **kwargs):  # noqa: E501
        """create_role  # noqa: E501

        Create customer role  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_role(customer_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param CustomerRoleCreate payload: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRole
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_role_with_http_info(customer_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.create_role_with_http_info(customer_id, payload, **kwargs)  # noqa: E501
            return data

    def create_role_with_http_info(self, customer_id, payload, **kwargs):  # noqa: E501
        """create_role  # noqa: E501

        Create customer role  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_role_with_http_info(customer_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param CustomerRoleCreate payload: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRole
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_role" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_role`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `create_role`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/roles', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomerRole',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_template_from_vm(self, customer_id, cloudspace_id, vm_id, template_name, **kwargs):  # noqa: E501
        """create_template_from_vm  # noqa: E501

        Create a template from virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_template_from_vm(customer_id, cloudspace_id, vm_id, template_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str template_name: Name of the template to be created (required)
        :param str callback_url: Callback url so that the API caller can be notified If this is specified the G8 will not send an email itself upon completion.
        :param str x_fields: An optional fields mask
        :return: CreateTemplateModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_template_from_vm_with_http_info(customer_id, cloudspace_id, vm_id, template_name, **kwargs)  # noqa: E501
        else:
            (data) = self.create_template_from_vm_with_http_info(customer_id, cloudspace_id, vm_id, template_name, **kwargs)  # noqa: E501
            return data

    def create_template_from_vm_with_http_info(self, customer_id, cloudspace_id, vm_id, template_name, **kwargs):  # noqa: E501
        """create_template_from_vm  # noqa: E501

        Create a template from virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_template_from_vm_with_http_info(customer_id, cloudspace_id, vm_id, template_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str template_name: Name of the template to be created (required)
        :param str callback_url: Callback url so that the API caller can be notified If this is specified the G8 will not send an email itself upon completion.
        :param str x_fields: An optional fields mask
        :return: CreateTemplateModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'template_name', 'callback_url', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_template_from_vm" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_template_from_vm`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `create_template_from_vm`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `create_template_from_vm`")  # noqa: E501
        # verify the required parameter 'template_name' is set
        if self.api_client.client_side_validation and ('template_name' not in params or
                                                       params['template_name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `template_name` when calling `create_template_from_vm`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'template_name' in params:
            query_params.append(('template_name', params['template_name']))  # noqa: E501
        if 'callback_url' in params:
            query_params.append(('callback_url', params['callback_url']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/template', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateTemplateModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_virtual_machine(self, customer_id, cloudspace_id, name, description, vcpus, memory, **kwargs):  # noqa: E501
        """create_virtual_machine  # noqa: E501

        Create VirtualMachine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_virtual_machine(customer_id, cloudspace_id, name, description, vcpus, memory, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str name: Virtual Machine name (required)
        :param str description: Virtual Machine Description (required)
        :param int vcpus: Number of cpu to assign to machine (required)
        :param int memory: Amount of memory to assign to machine in MiB (required)
        :param list[int] data_disks: List of extra disk sizes
        :param str private_ip: Private ip of the machine
        :param str user_data: Custom user data in a YAML string for cloud-init
        :param int image_id: Id of the specific image
        :param int disk_size: Boot Disk Size in GiB
        :param int cdrom_id: CD-ROM Image ID
        :param int boot_disk_id: BOOT Disk ID for creating with snapshot or with existing disk
        :param str os_type: OS type used on machine
        :param str os_name: Image OS name
        :param bool enable_vm_agent: whether or not to enable agent communication
        :param str snapshot_id: Boot Disk Snapshot ID
        :param bool all_vm_disks: Create clones of all snapshots that were created in the same snapshot
        :param str boot_type: Boot type to be used when creating from snapshot or creating empty machine
        :param VMCreateExtentions payload:
        :param str x_fields: An optional fields mask
        :return: VmIdModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_virtual_machine_with_http_info(customer_id, cloudspace_id, name, description, vcpus, memory, **kwargs)  # noqa: E501
        else:
            (data) = self.create_virtual_machine_with_http_info(customer_id, cloudspace_id, name, description, vcpus, memory, **kwargs)  # noqa: E501
            return data

    def create_virtual_machine_with_http_info(self, customer_id, cloudspace_id, name, description, vcpus, memory, **kwargs):  # noqa: E501
        """create_virtual_machine  # noqa: E501

        Create VirtualMachine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_virtual_machine_with_http_info(customer_id, cloudspace_id, name, description, vcpus, memory, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str name: Virtual Machine name (required)
        :param str description: Virtual Machine Description (required)
        :param int vcpus: Number of cpu to assign to machine (required)
        :param int memory: Amount of memory to assign to machine in MiB (required)
        :param list[int] data_disks: List of extra disk sizes
        :param str private_ip: Private ip of the machine
        :param str user_data: Custom user data in a YAML string for cloud-init
        :param int image_id: Id of the specific image
        :param int disk_size: Boot Disk Size in GiB
        :param int cdrom_id: CD-ROM Image ID
        :param int boot_disk_id: BOOT Disk ID for creating with snapshot or with existing disk
        :param str os_type: OS type used on machine
        :param str os_name: Image OS name
        :param bool enable_vm_agent: whether or not to enable agent communication
        :param str snapshot_id: Boot Disk Snapshot ID
        :param bool all_vm_disks: Create clones of all snapshots that were created in the same snapshot
        :param str boot_type: Boot type to be used when creating from snapshot or creating empty machine
        :param VMCreateExtentions payload:
        :param str x_fields: An optional fields mask
        :return: VmIdModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'name', 'description', 'vcpus', 'memory', 'data_disks', 'private_ip', 'user_data', 'image_id', 'disk_size', 'cdrom_id', 'boot_disk_id', 'os_type', 'os_name', 'enable_vm_agent', 'snapshot_id', 'all_vm_disks', 'boot_type', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `create_virtual_machine`")  # noqa: E501
        # verify the required parameter 'name' is set
        if self.api_client.client_side_validation and ('name' not in params or
                                                       params['name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `name` when calling `create_virtual_machine`")  # noqa: E501
        # verify the required parameter 'description' is set
        if self.api_client.client_side_validation and ('description' not in params or
                                                       params['description'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `description` when calling `create_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vcpus' is set
        if self.api_client.client_side_validation and ('vcpus' not in params or
                                                       params['vcpus'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vcpus` when calling `create_virtual_machine`")  # noqa: E501
        # verify the required parameter 'memory' is set
        if self.api_client.client_side_validation and ('memory' not in params or
                                                       params['memory'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `memory` when calling `create_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'name' in params:
            query_params.append(('name', params['name']))  # noqa: E501
        if 'description' in params:
            query_params.append(('description', params['description']))  # noqa: E501
        if 'data_disks' in params:
            query_params.append(('data_disks', params['data_disks']))  # noqa: E501
            collection_formats['data_disks'] = 'csv'  # noqa: E501
        if 'vcpus' in params:
            query_params.append(('vcpus', params['vcpus']))  # noqa: E501
        if 'memory' in params:
            query_params.append(('memory', params['memory']))  # noqa: E501
        if 'private_ip' in params:
            query_params.append(('private_ip', params['private_ip']))  # noqa: E501
        if 'user_data' in params:
            query_params.append(('user_data', params['user_data']))  # noqa: E501
        if 'image_id' in params:
            query_params.append(('image_id', params['image_id']))  # noqa: E501
        if 'disk_size' in params:
            query_params.append(('disk_size', params['disk_size']))  # noqa: E501
        if 'cdrom_id' in params:
            query_params.append(('cdrom_id', params['cdrom_id']))  # noqa: E501
        if 'boot_disk_id' in params:
            query_params.append(('boot_disk_id', params['boot_disk_id']))  # noqa: E501
        if 'os_type' in params:
            query_params.append(('os_type', params['os_type']))  # noqa: E501
        if 'os_name' in params:
            query_params.append(('os_name', params['os_name']))  # noqa: E501
        if 'enable_vm_agent' in params:
            query_params.append(('enable_vm_agent', params['enable_vm_agent']))  # noqa: E501
        if 'snapshot_id' in params:
            query_params.append(('snapshot_id', params['snapshot_id']))  # noqa: E501
        if 'all_vm_disks' in params:
            query_params.append(('all_vm_disks', params['all_vm_disks']))  # noqa: E501
        if 'boot_type' in params:
            query_params.append(('boot_type', params['boot_type']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VmIdModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_virtual_machine_from_s3(self, customer_id, cloudspace_id, link, key, secret, region, bucket, object_name, name, description, vcpus, memory, os_name, **kwargs):  # noqa: E501
        """create_virtual_machine_from_s3  # noqa: E501

        Import and create virtual machine from s3  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_virtual_machine_from_s3(customer_id, cloudspace_id, link, key, secret, region, bucket, object_name, name, description, vcpus, memory, os_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str link: S3 server link (required)
        :param str key: access key to the server (required)
        :param str secret: secret to access the server (required)
        :param str region: region of the s3 server (required)
        :param str bucket: Name of the bucket (required)
        :param str object_name: Name of the stored object in the bucker (required)
        :param str name: Virtual Machine name (required)
        :param str description: Virtual Machine Description (required)
        :param int vcpus: Number of cpu to assign to machine (required)
        :param int memory: Amount of memory to assign to machine in MiB (required)
        :param str os_name: Image OS name (required)
        :param str private_ip: Private ip of the machine
        :param bool strict: Import vm as close as possible to original hw
        :param str boot_type: Boot type
        :param str os_type: Image OS type
        :param str x_fields: An optional fields mask
        :return: VmIdModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_virtual_machine_from_s3_with_http_info(customer_id, cloudspace_id, link, key, secret, region, bucket, object_name, name, description, vcpus, memory, os_name, **kwargs)  # noqa: E501
        else:
            (data) = self.create_virtual_machine_from_s3_with_http_info(customer_id, cloudspace_id, link, key, secret, region, bucket, object_name, name, description, vcpus, memory, os_name, **kwargs)  # noqa: E501
            return data

    def create_virtual_machine_from_s3_with_http_info(self, customer_id, cloudspace_id, link, key, secret, region, bucket, object_name, name, description, vcpus, memory, os_name, **kwargs):  # noqa: E501
        """create_virtual_machine_from_s3  # noqa: E501

        Import and create virtual machine from s3  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_virtual_machine_from_s3_with_http_info(customer_id, cloudspace_id, link, key, secret, region, bucket, object_name, name, description, vcpus, memory, os_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str link: S3 server link (required)
        :param str key: access key to the server (required)
        :param str secret: secret to access the server (required)
        :param str region: region of the s3 server (required)
        :param str bucket: Name of the bucket (required)
        :param str object_name: Name of the stored object in the bucker (required)
        :param str name: Virtual Machine name (required)
        :param str description: Virtual Machine Description (required)
        :param int vcpus: Number of cpu to assign to machine (required)
        :param int memory: Amount of memory to assign to machine in MiB (required)
        :param str os_name: Image OS name (required)
        :param str private_ip: Private ip of the machine
        :param bool strict: Import vm as close as possible to original hw
        :param str boot_type: Boot type
        :param str os_type: Image OS type
        :param str x_fields: An optional fields mask
        :return: VmIdModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'link', 'key', 'secret', 'region', 'bucket', 'object_name', 'name', 'description', 'vcpus', 'memory', 'os_name', 'private_ip', 'strict', 'boot_type', 'os_type', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_virtual_machine_from_s3" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_virtual_machine_from_s3`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `create_virtual_machine_from_s3`")  # noqa: E501
        # verify the required parameter 'link' is set
        if self.api_client.client_side_validation and ('link' not in params or
                                                       params['link'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `link` when calling `create_virtual_machine_from_s3`")  # noqa: E501
        # verify the required parameter 'key' is set
        if self.api_client.client_side_validation and ('key' not in params or
                                                       params['key'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `key` when calling `create_virtual_machine_from_s3`")  # noqa: E501
        # verify the required parameter 'secret' is set
        if self.api_client.client_side_validation and ('secret' not in params or
                                                       params['secret'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `secret` when calling `create_virtual_machine_from_s3`")  # noqa: E501
        # verify the required parameter 'region' is set
        if self.api_client.client_side_validation and ('region' not in params or
                                                       params['region'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `region` when calling `create_virtual_machine_from_s3`")  # noqa: E501
        # verify the required parameter 'bucket' is set
        if self.api_client.client_side_validation and ('bucket' not in params or
                                                       params['bucket'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `bucket` when calling `create_virtual_machine_from_s3`")  # noqa: E501
        # verify the required parameter 'object_name' is set
        if self.api_client.client_side_validation and ('object_name' not in params or
                                                       params['object_name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `object_name` when calling `create_virtual_machine_from_s3`")  # noqa: E501
        # verify the required parameter 'name' is set
        if self.api_client.client_side_validation and ('name' not in params or
                                                       params['name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `name` when calling `create_virtual_machine_from_s3`")  # noqa: E501
        # verify the required parameter 'description' is set
        if self.api_client.client_side_validation and ('description' not in params or
                                                       params['description'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `description` when calling `create_virtual_machine_from_s3`")  # noqa: E501
        # verify the required parameter 'vcpus' is set
        if self.api_client.client_side_validation and ('vcpus' not in params or
                                                       params['vcpus'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vcpus` when calling `create_virtual_machine_from_s3`")  # noqa: E501
        # verify the required parameter 'memory' is set
        if self.api_client.client_side_validation and ('memory' not in params or
                                                       params['memory'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `memory` when calling `create_virtual_machine_from_s3`")  # noqa: E501
        # verify the required parameter 'os_name' is set
        if self.api_client.client_side_validation and ('os_name' not in params or
                                                       params['os_name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `os_name` when calling `create_virtual_machine_from_s3`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'link' in params:
            query_params.append(('link', params['link']))  # noqa: E501
        if 'key' in params:
            query_params.append(('key', params['key']))  # noqa: E501
        if 'secret' in params:
            query_params.append(('secret', params['secret']))  # noqa: E501
        if 'region' in params:
            query_params.append(('region', params['region']))  # noqa: E501
        if 'bucket' in params:
            query_params.append(('bucket', params['bucket']))  # noqa: E501
        if 'object_name' in params:
            query_params.append(('object_name', params['object_name']))  # noqa: E501
        if 'name' in params:
            query_params.append(('name', params['name']))  # noqa: E501
        if 'description' in params:
            query_params.append(('description', params['description']))  # noqa: E501
        if 'vcpus' in params:
            query_params.append(('vcpus', params['vcpus']))  # noqa: E501
        if 'memory' in params:
            query_params.append(('memory', params['memory']))  # noqa: E501
        if 'private_ip' in params:
            query_params.append(('private_ip', params['private_ip']))  # noqa: E501
        if 'strict' in params:
            query_params.append(('strict', params['strict']))  # noqa: E501
        if 'boot_type' in params:
            query_params.append(('boot_type', params['boot_type']))  # noqa: E501
        if 'os_type' in params:
            query_params.append(('os_type', params['os_type']))  # noqa: E501
        if 'os_name' in params:
            query_params.append(('os_name', params['os_name']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/import-s3', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VmIdModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_virtual_machine_note(self, customer_id, cloudspace_id, vm_id, payload, **kwargs):  # noqa: E501
        """create_virtual_machine_note  # noqa: E501

        Create virtual machine note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_virtual_machine_note(customer_id, cloudspace_id, vm_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_virtual_machine_note_with_http_info(customer_id, cloudspace_id, vm_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.create_virtual_machine_note_with_http_info(customer_id, cloudspace_id, vm_id, payload, **kwargs)  # noqa: E501
            return data

    def create_virtual_machine_note_with_http_info(self, customer_id, cloudspace_id, vm_id, payload, **kwargs):  # noqa: E501
        """create_virtual_machine_note  # noqa: E501

        Create virtual machine note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_virtual_machine_note_with_http_info(customer_id, cloudspace_id, vm_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_virtual_machine_note" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `create_virtual_machine_note`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `create_virtual_machine_note`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `create_virtual_machine_note`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `create_virtual_machine_note`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/notes', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_anti_affinity_group_virtual_machine(self, customer_id, cloudspace_id, group_id, vm_id, **kwargs):  # noqa: E501
        """delete_anti_affinity_group_virtual_machine  # noqa: E501

        Delete anti-affinity group virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_anti_affinity_group_virtual_machine(customer_id, cloudspace_id, group_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str group_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_anti_affinity_group_virtual_machine_with_http_info(customer_id, cloudspace_id, group_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_anti_affinity_group_virtual_machine_with_http_info(customer_id, cloudspace_id, group_id, vm_id, **kwargs)  # noqa: E501
            return data

    def delete_anti_affinity_group_virtual_machine_with_http_info(self, customer_id, cloudspace_id, group_id, vm_id, **kwargs):  # noqa: E501
        """delete_anti_affinity_group_virtual_machine  # noqa: E501

        Delete anti-affinity group virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_anti_affinity_group_virtual_machine_with_http_info(customer_id, cloudspace_id, group_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str group_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'group_id', 'vm_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_anti_affinity_group_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_anti_affinity_group_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `delete_anti_affinity_group_virtual_machine`")  # noqa: E501
        # verify the required parameter 'group_id' is set
        if self.api_client.client_side_validation and ('group_id' not in params or
                                                       params['group_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `group_id` when calling `delete_anti_affinity_group_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `delete_anti_affinity_group_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'group_id' in params:
            path_params['group_id'] = params['group_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/anti-affinity-groups/{group_id}/vms/{vm_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_bucket(self, customer_id, objectspace_id, bucket_id, **kwargs):  # noqa: E501
        """delete_bucket  # noqa: E501

        Delete a given bucket  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_bucket(customer_id, objectspace_id, bucket_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str bucket_id: (required)
        :param bool permanently: permanently deleting your bucket
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_bucket_with_http_info(customer_id, objectspace_id, bucket_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_bucket_with_http_info(customer_id, objectspace_id, bucket_id, **kwargs)  # noqa: E501
            return data

    def delete_bucket_with_http_info(self, customer_id, objectspace_id, bucket_id, **kwargs):  # noqa: E501
        """delete_bucket  # noqa: E501

        Delete a given bucket  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_bucket_with_http_info(customer_id, objectspace_id, bucket_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str bucket_id: (required)
        :param bool permanently: permanently deleting your bucket
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'objectspace_id', 'bucket_id', 'permanently', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_bucket" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_bucket`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `delete_bucket`")  # noqa: E501
        # verify the required parameter 'bucket_id' is set
        if self.api_client.client_side_validation and ('bucket_id' not in params or
                                                       params['bucket_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `bucket_id` when calling `delete_bucket`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'objectspace_id' in params:
            path_params['objectspace_id'] = params['objectspace_id']  # noqa: E501
        if 'bucket_id' in params:
            path_params['bucket_id'] = params['bucket_id']  # noqa: E501

        query_params = []
        if 'permanently' in params:
            query_params.append(('permanently', params['permanently']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces/{objectspace_id}/buckets/{bucket_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_certificate(self, customer_id, domain, **kwargs):  # noqa: E501
        """delete_certificate  # noqa: E501

        Delete certificate  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_certificate(customer_id, domain, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str domain: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_certificate_with_http_info(customer_id, domain, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_certificate_with_http_info(customer_id, domain, **kwargs)  # noqa: E501
            return data

    def delete_certificate_with_http_info(self, customer_id, domain, **kwargs):  # noqa: E501
        """delete_certificate  # noqa: E501

        Delete certificate  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_certificate_with_http_info(customer_id, domain, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str domain: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'domain']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_certificate" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_certificate`")  # noqa: E501
        # verify the required parameter 'domain' is set
        if self.api_client.client_side_validation and ('domain' not in params or
                                                       params['domain'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `domain` when calling `delete_certificate`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'domain' in params:
            path_params['domain'] = params['domain']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/certificates/ssl/{domain}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_cloudspace(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """delete_cloudspace  # noqa: E501

        Delete cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_cloudspace(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param bool permanently: Delete permanently
        :param str reason: Reason for deleting
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_cloudspace_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_cloudspace_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def delete_cloudspace_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """delete_cloudspace  # noqa: E501

        Delete cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_cloudspace_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param bool permanently: Delete permanently
        :param str reason: Reason for deleting
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'permanently', 'reason', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_cloudspace" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_cloudspace`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `delete_cloudspace`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'permanently' in params:
            query_params.append(('permanently', params['permanently']))  # noqa: E501
        if 'reason' in params:
            query_params.append(('reason', params['reason']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_cloudspace_anti_affinity_group(self, customer_id, cloudspace_id, group_id, **kwargs):  # noqa: E501
        """delete_cloudspace_anti_affinity_group  # noqa: E501

        Delete anti-affinity group  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_cloudspace_anti_affinity_group(customer_id, cloudspace_id, group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str group_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_cloudspace_anti_affinity_group_with_http_info(customer_id, cloudspace_id, group_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_cloudspace_anti_affinity_group_with_http_info(customer_id, cloudspace_id, group_id, **kwargs)  # noqa: E501
            return data

    def delete_cloudspace_anti_affinity_group_with_http_info(self, customer_id, cloudspace_id, group_id, **kwargs):  # noqa: E501
        """delete_cloudspace_anti_affinity_group  # noqa: E501

        Delete anti-affinity group  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_cloudspace_anti_affinity_group_with_http_info(customer_id, cloudspace_id, group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str group_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'group_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_cloudspace_anti_affinity_group" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_cloudspace_anti_affinity_group`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `delete_cloudspace_anti_affinity_group`")  # noqa: E501
        # verify the required parameter 'group_id' is set
        if self.api_client.client_side_validation and ('group_id' not in params or
                                                       params['group_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `group_id` when calling `delete_cloudspace_anti_affinity_group`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'group_id' in params:
            path_params['group_id'] = params['group_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/anti-affinity-groups/{group_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_cloudspace_note(self, customer_id, cloudspace_id, note_id, **kwargs):  # noqa: E501
        """delete_cloudspace_note  # noqa: E501

        Delete cloudspace note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_cloudspace_note(customer_id, cloudspace_id, note_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str note_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_cloudspace_note_with_http_info(customer_id, cloudspace_id, note_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_cloudspace_note_with_http_info(customer_id, cloudspace_id, note_id, **kwargs)  # noqa: E501
            return data

    def delete_cloudspace_note_with_http_info(self, customer_id, cloudspace_id, note_id, **kwargs):  # noqa: E501
        """delete_cloudspace_note  # noqa: E501

        Delete cloudspace note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_cloudspace_note_with_http_info(customer_id, cloudspace_id, note_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str note_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'note_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_cloudspace_note" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_cloudspace_note`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `delete_cloudspace_note`")  # noqa: E501
        # verify the required parameter 'note_id' is set
        if self.api_client.client_side_validation and ('note_id' not in params or
                                                       params['note_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `note_id` when calling `delete_cloudspace_note`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'note_id' in params:
            path_params['note_id'] = params['note_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/notes/{note_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_cloudspace_proxy_config(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """delete_cloudspace_proxy_config  # noqa: E501

        Delete cloudspace proxy config  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_cloudspace_proxy_config(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_cloudspace_proxy_config_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_cloudspace_proxy_config_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def delete_cloudspace_proxy_config_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """delete_cloudspace_proxy_config  # noqa: E501

        Delete cloudspace proxy config  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_cloudspace_proxy_config_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_cloudspace_proxy_config" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_cloudspace_proxy_config`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `delete_cloudspace_proxy_config`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/proxy-server', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_customer(self, customer_id, **kwargs):  # noqa: E501
        """delete_customer  # noqa: E501

        Delete customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_customer(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str reason: Reason for deletion (Optional)
        :param bool recursive_delete: Delete the customer recursively
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_customer_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_customer_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def delete_customer_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """delete_customer  # noqa: E501

        Delete customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_customer_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str reason: Reason for deletion (Optional)
        :param bool recursive_delete: Delete the customer recursively
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'reason', 'recursive_delete']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_customer" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_customer`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []
        if 'reason' in params:
            query_params.append(('reason', params['reason']))  # noqa: E501
        if 'recursive_delete' in params:
            query_params.append(('recursive_delete', params['recursive_delete']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_customer_cdrom_image(self, customer_id, location, cdrom_id, **kwargs):  # noqa: E501
        """delete_customer_cdrom_image  # noqa: E501

        Delete customer CDROM images  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_customer_cdrom_image(customer_id, location, cdrom_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int cdrom_id: (required)
        :param bool permanently: If set to False, the CD-ROM will be moved to the Recycle Bin, if set to True the CD-ROM will be permanently deleted.
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_customer_cdrom_image_with_http_info(customer_id, location, cdrom_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_customer_cdrom_image_with_http_info(customer_id, location, cdrom_id, **kwargs)  # noqa: E501
            return data

    def delete_customer_cdrom_image_with_http_info(self, customer_id, location, cdrom_id, **kwargs):  # noqa: E501
        """delete_customer_cdrom_image  # noqa: E501

        Delete customer CDROM images  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_customer_cdrom_image_with_http_info(customer_id, location, cdrom_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int cdrom_id: (required)
        :param bool permanently: If set to False, the CD-ROM will be moved to the Recycle Bin, if set to True the CD-ROM will be permanently deleted.
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'cdrom_id', 'permanently', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_customer_cdrom_image" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_customer_cdrom_image`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `delete_customer_cdrom_image`")  # noqa: E501
        # verify the required parameter 'cdrom_id' is set
        if self.api_client.client_side_validation and ('cdrom_id' not in params or
                                                       params['cdrom_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cdrom_id` when calling `delete_customer_cdrom_image`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'cdrom_id' in params:
            path_params['cdrom_id'] = params['cdrom_id']  # noqa: E501

        query_params = []
        if 'permanently' in params:
            query_params.append(('permanently', params['permanently']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/cdrom-images/{cdrom_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_customer_image(self, customer_id, location, image_id, **kwargs):  # noqa: E501
        """delete_customer_image  # noqa: E501

        Delete customer Image  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_customer_image(customer_id, location, image_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int image_id: (required)
        :param bool permanently: If set to False, the Image will be moved to the Recycle Bin, if set to True the Image will be permanently deleted.
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_customer_image_with_http_info(customer_id, location, image_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_customer_image_with_http_info(customer_id, location, image_id, **kwargs)  # noqa: E501
            return data

    def delete_customer_image_with_http_info(self, customer_id, location, image_id, **kwargs):  # noqa: E501
        """delete_customer_image  # noqa: E501

        Delete customer Image  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_customer_image_with_http_info(customer_id, location, image_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int image_id: (required)
        :param bool permanently: If set to False, the Image will be moved to the Recycle Bin, if set to True the Image will be permanently deleted.
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'image_id', 'permanently', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_customer_image" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_customer_image`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `delete_customer_image`")  # noqa: E501
        # verify the required parameter 'image_id' is set
        if self.api_client.client_side_validation and ('image_id' not in params or
                                                       params['image_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `image_id` when calling `delete_customer_image`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'image_id' in params:
            path_params['image_id'] = params['image_id']  # noqa: E501

        query_params = []
        if 'permanently' in params:
            query_params.append(('permanently', params['permanently']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/vm-images/{image_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_disk(self, customer_id, location, disk_id, **kwargs):  # noqa: E501
        """delete_disk  # noqa: E501

        Delete disk  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_disk(customer_id, location, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param bool detach: Detach from Virtual Machine first
        :param bool permanently: If set to False, the disk will be moved to the Recycle Bin, if set to True the disk will be permanently deleted.
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_disk_with_http_info(customer_id, location, disk_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_disk_with_http_info(customer_id, location, disk_id, **kwargs)  # noqa: E501
            return data

    def delete_disk_with_http_info(self, customer_id, location, disk_id, **kwargs):  # noqa: E501
        """delete_disk  # noqa: E501

        Delete disk  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_disk_with_http_info(customer_id, location, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param bool detach: Detach from Virtual Machine first
        :param bool permanently: If set to False, the disk will be moved to the Recycle Bin, if set to True the disk will be permanently deleted.
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'detach', 'permanently', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_disk" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_disk`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `delete_disk`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `delete_disk`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501

        query_params = []
        if 'detach' in params:
            query_params.append(('detach', params['detach']))  # noqa: E501
        if 'permanently' in params:
            query_params.append(('permanently', params['permanently']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_disk_note(self, customer_id, location, disk_id, note_id, **kwargs):  # noqa: E501
        """delete_disk_note  # noqa: E501

        Delete disk note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_disk_note(customer_id, location, disk_id, note_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str note_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_disk_note_with_http_info(customer_id, location, disk_id, note_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_disk_note_with_http_info(customer_id, location, disk_id, note_id, **kwargs)  # noqa: E501
            return data

    def delete_disk_note_with_http_info(self, customer_id, location, disk_id, note_id, **kwargs):  # noqa: E501
        """delete_disk_note  # noqa: E501

        Delete disk note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_disk_note_with_http_info(customer_id, location, disk_id, note_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str note_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'note_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_disk_note" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_disk_note`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `delete_disk_note`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `delete_disk_note`")  # noqa: E501
        # verify the required parameter 'note_id' is set
        if self.api_client.client_side_validation and ('note_id' not in params or
                                                       params['note_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `note_id` when calling `delete_disk_note`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501
        if 'note_id' in params:
            path_params['note_id'] = params['note_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/notes/{note_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_disk_snapshot(self, customer_id, location, disk_id, snapshot_id, **kwargs):  # noqa: E501
        """delete_disk_snapshot  # noqa: E501

        Delete Disk snapshot  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_disk_snapshot(customer_id, location, disk_id, snapshot_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str snapshot_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_disk_snapshot_with_http_info(customer_id, location, disk_id, snapshot_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_disk_snapshot_with_http_info(customer_id, location, disk_id, snapshot_id, **kwargs)  # noqa: E501
            return data

    def delete_disk_snapshot_with_http_info(self, customer_id, location, disk_id, snapshot_id, **kwargs):  # noqa: E501
        """delete_disk_snapshot  # noqa: E501

        Delete Disk snapshot  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_disk_snapshot_with_http_info(customer_id, location, disk_id, snapshot_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str snapshot_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'snapshot_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_disk_snapshot" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `delete_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `delete_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'snapshot_id' is set
        if self.api_client.client_side_validation and ('snapshot_id' not in params or
                                                       params['snapshot_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `snapshot_id` when calling `delete_disk_snapshot`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501
        if 'snapshot_id' in params:
            path_params['snapshot_id'] = params['snapshot_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/snapshots/{snapshot_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_file(self, customer_id, cloudspace_id, vm_id, filepath, **kwargs):  # noqa: E501
        """delete_file  # noqa: E501

        Delete file from virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_file(customer_id, cloudspace_id, vm_id, filepath, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str filepath: filepath to read from (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_file_with_http_info(customer_id, cloudspace_id, vm_id, filepath, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_file_with_http_info(customer_id, cloudspace_id, vm_id, filepath, **kwargs)  # noqa: E501
            return data

    def delete_file_with_http_info(self, customer_id, cloudspace_id, vm_id, filepath, **kwargs):  # noqa: E501
        """delete_file  # noqa: E501

        Delete file from virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_file_with_http_info(customer_id, cloudspace_id, vm_id, filepath, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str filepath: filepath to read from (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'filepath', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_file" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_file`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `delete_file`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `delete_file`")  # noqa: E501
        # verify the required parameter 'filepath' is set
        if self.api_client.client_side_validation and ('filepath' not in params or
                                                       params['filepath'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `filepath` when calling `delete_file`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'filepath' in params:
            query_params.append(('filepath', params['filepath']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/file', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_objectspace(self, customer_id, objectspace_id, **kwargs):  # noqa: E501
        """delete_objectspace  # noqa: E501

        Delete an objectspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_objectspace(customer_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param bool permanently: deleting the object space permanently or not
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_objectspace_with_http_info(customer_id, objectspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_objectspace_with_http_info(customer_id, objectspace_id, **kwargs)  # noqa: E501
            return data

    def delete_objectspace_with_http_info(self, customer_id, objectspace_id, **kwargs):  # noqa: E501
        """delete_objectspace  # noqa: E501

        Delete an objectspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_objectspace_with_http_info(customer_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param bool permanently: deleting the object space permanently or not
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'objectspace_id', 'permanently', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_objectspace" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_objectspace`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `delete_objectspace`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'objectspace_id' in params:
            path_params['objectspace_id'] = params['objectspace_id']  # noqa: E501

        query_params = []
        if 'permanently' in params:
            query_params.append(('permanently', params['permanently']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces/{objectspace_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_objectspace_note(self, customer_id, objectspace_id, note_id, **kwargs):  # noqa: E501
        """delete_objectspace_note  # noqa: E501

        Delete objectspace note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_objectspace_note(customer_id, objectspace_id, note_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str note_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_objectspace_note_with_http_info(customer_id, objectspace_id, note_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_objectspace_note_with_http_info(customer_id, objectspace_id, note_id, **kwargs)  # noqa: E501
            return data

    def delete_objectspace_note_with_http_info(self, customer_id, objectspace_id, note_id, **kwargs):  # noqa: E501
        """delete_objectspace_note  # noqa: E501

        Delete objectspace note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_objectspace_note_with_http_info(customer_id, objectspace_id, note_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str note_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'objectspace_id', 'note_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_objectspace_note" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_objectspace_note`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `delete_objectspace_note`")  # noqa: E501
        # verify the required parameter 'note_id' is set
        if self.api_client.client_side_validation and ('note_id' not in params or
                                                       params['note_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `note_id` when calling `delete_objectspace_note`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'objectspace_id' in params:
            path_params['objectspace_id'] = params['objectspace_id']  # noqa: E501
        if 'note_id' in params:
            path_params['note_id'] = params['note_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces/{objectspace_id}/notes/{note_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_portforward(self, customer_id, cloudspace_id, portforward_id, **kwargs):  # noqa: E501
        """delete_portforward  # noqa: E501

        Delete cloudspace port forward  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_portforward(customer_id, cloudspace_id, portforward_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str portforward_id: (required)
        :param str x_fields: An optional fields mask
        :return: Portforwards
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_portforward_with_http_info(customer_id, cloudspace_id, portforward_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_portforward_with_http_info(customer_id, cloudspace_id, portforward_id, **kwargs)  # noqa: E501
            return data

    def delete_portforward_with_http_info(self, customer_id, cloudspace_id, portforward_id, **kwargs):  # noqa: E501
        """delete_portforward  # noqa: E501

        Delete cloudspace port forward  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_portforward_with_http_info(customer_id, cloudspace_id, portforward_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str portforward_id: (required)
        :param str x_fields: An optional fields mask
        :return: Portforwards
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'portforward_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_portforward" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_portforward`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `delete_portforward`")  # noqa: E501
        # verify the required parameter 'portforward_id' is set
        if self.api_client.client_side_validation and ('portforward_id' not in params or
                                                       params['portforward_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `portforward_id` when calling `delete_portforward`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'portforward_id' in params:
            path_params['portforward_id'] = params['portforward_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/portforwards/{portforward_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Portforwards',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_remote_cloudspace_connection(self, customer_id, cloudspace_id, connected_cloudspace_id, **kwargs):  # noqa: E501
        """delete_remote_cloudspace_connection  # noqa: E501

        Delete remote connection to cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_remote_cloudspace_connection(customer_id, cloudspace_id, connected_cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str connected_cloudspace_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_remote_cloudspace_connection_with_http_info(customer_id, cloudspace_id, connected_cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_remote_cloudspace_connection_with_http_info(customer_id, cloudspace_id, connected_cloudspace_id, **kwargs)  # noqa: E501
            return data

    def delete_remote_cloudspace_connection_with_http_info(self, customer_id, cloudspace_id, connected_cloudspace_id, **kwargs):  # noqa: E501
        """delete_remote_cloudspace_connection  # noqa: E501

        Delete remote connection to cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_remote_cloudspace_connection_with_http_info(customer_id, cloudspace_id, connected_cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str connected_cloudspace_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'connected_cloudspace_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_remote_cloudspace_connection" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_remote_cloudspace_connection`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `delete_remote_cloudspace_connection`")  # noqa: E501
        # verify the required parameter 'connected_cloudspace_id' is set
        if self.api_client.client_side_validation and ('connected_cloudspace_id' not in params or
                                                       params['connected_cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `connected_cloudspace_id` when calling `delete_remote_cloudspace_connection`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'connected_cloudspace_id' in params:
            path_params['connected_cloudspace_id'] = params['connected_cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/connected-cloudspaces/{connected_cloudspace_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_role(self, customer_id, role_id, **kwargs):  # noqa: E501
        """delete_role  # noqa: E501

        Delete customer role  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_role(customer_id, role_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str role_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_role_with_http_info(customer_id, role_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_role_with_http_info(customer_id, role_id, **kwargs)  # noqa: E501
            return data

    def delete_role_with_http_info(self, customer_id, role_id, **kwargs):  # noqa: E501
        """delete_role  # noqa: E501

        Delete customer role  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_role_with_http_info(customer_id, role_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str role_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'role_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_role" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_role`")  # noqa: E501
        # verify the required parameter 'role_id' is set
        if self.api_client.client_side_validation and ('role_id' not in params or
                                                       params['role_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `role_id` when calling `delete_role`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'role_id' in params:
            path_params['role_id'] = params['role_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/roles/{role_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_support_access(self, customer_id, **kwargs):  # noqa: E501
        """delete_support_access  # noqa: E501

        delete support organization access  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_support_access(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_support_access_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_support_access_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def delete_support_access_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """delete_support_access  # noqa: E501

        delete support organization access  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_support_access_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_support_access" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_support_access`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/support-access', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_virtual_machine(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """delete_virtual_machine  # noqa: E501

        Delete Virtual Machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_virtual_machine(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param bool permanently: If set to False, the virtual machine will be moved to the Recycle Bin, if set to True the virtual machine will be permanently deleted.
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def delete_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """delete_virtual_machine  # noqa: E501

        Delete Virtual Machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param bool permanently: If set to False, the virtual machine will be moved to the Recycle Bin, if set to True the virtual machine will be permanently deleted.
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'permanently', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `delete_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `delete_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'permanently' in params:
            query_params.append(('permanently', params['permanently']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_virtual_machine_note(self, customer_id, cloudspace_id, vm_id, note_id, **kwargs):  # noqa: E501
        """delete_virtual_machine_note  # noqa: E501

        Delete virtual machine note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_virtual_machine_note(customer_id, cloudspace_id, vm_id, note_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str note_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.delete_virtual_machine_note_with_http_info(customer_id, cloudspace_id, vm_id, note_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_virtual_machine_note_with_http_info(customer_id, cloudspace_id, vm_id, note_id, **kwargs)  # noqa: E501
            return data

    def delete_virtual_machine_note_with_http_info(self, customer_id, cloudspace_id, vm_id, note_id, **kwargs):  # noqa: E501
        """delete_virtual_machine_note  # noqa: E501

        Delete virtual machine note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_virtual_machine_note_with_http_info(customer_id, cloudspace_id, vm_id, note_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str note_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'note_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_virtual_machine_note" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `delete_virtual_machine_note`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `delete_virtual_machine_note`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `delete_virtual_machine_note`")  # noqa: E501
        # verify the required parameter 'note_id' is set
        if self.api_client.client_side_validation and ('note_id' not in params or
                                                       params['note_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `note_id` when calling `delete_virtual_machine_note`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501
        if 'note_id' in params:
            path_params['note_id'] = params['note_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/notes/{note_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def detach_disk_virtual_machine(self, customer_id, cloudspace_id, vm_id, disk_id, **kwargs):  # noqa: E501
        """detach_disk_virtual_machine  # noqa: E501

        Detach a disk on virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.detach_disk_virtual_machine(customer_id, cloudspace_id, vm_id, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int disk_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.detach_disk_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, disk_id, **kwargs)  # noqa: E501
        else:
            (data) = self.detach_disk_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, disk_id, **kwargs)  # noqa: E501
            return data

    def detach_disk_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, disk_id, **kwargs):  # noqa: E501
        """detach_disk_virtual_machine  # noqa: E501

        Detach a disk on virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.detach_disk_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int disk_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'disk_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method detach_disk_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `detach_disk_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `detach_disk_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `detach_disk_virtual_machine`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `detach_disk_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/disks/{disk_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def detach_external_networks_virtual_machine(self, customer_id, cloudspace_id, vm_id, external_ip_address, **kwargs):  # noqa: E501
        """detach_external_networks_virtual_machine  # noqa: E501

        Detach external network (NIC) from virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.detach_external_networks_virtual_machine(customer_id, cloudspace_id, vm_id, external_ip_address, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str external_ip_address: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.detach_external_networks_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, external_ip_address, **kwargs)  # noqa: E501
        else:
            (data) = self.detach_external_networks_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, external_ip_address, **kwargs)  # noqa: E501
            return data

    def detach_external_networks_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, external_ip_address, **kwargs):  # noqa: E501
        """detach_external_networks_virtual_machine  # noqa: E501

        Detach external network (NIC) from virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.detach_external_networks_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, external_ip_address, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str external_ip_address: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'external_ip_address', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method detach_external_networks_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `detach_external_networks_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `detach_external_networks_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `detach_external_networks_virtual_machine`")  # noqa: E501
        # verify the required parameter 'external_ip_address' is set
        if self.api_client.client_side_validation and ('external_ip_address' not in params or
                                                       params['external_ip_address'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `external_ip_address` when calling `detach_external_networks_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501
        if 'external_ip_address' in params:
            path_params['external_ip_address'] = params['external_ip_address']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/external-nics/{external_ip_address}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def detach_virtual_machine_cdrom(self, customer_id, cloudspace_id, vm_id, cdrom_id, **kwargs):  # noqa: E501
        """detach_virtual_machine_cdrom  # noqa: E501

        Detach CDROM image from virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.detach_virtual_machine_cdrom(customer_id, cloudspace_id, vm_id, cdrom_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int cdrom_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.detach_virtual_machine_cdrom_with_http_info(customer_id, cloudspace_id, vm_id, cdrom_id, **kwargs)  # noqa: E501
        else:
            (data) = self.detach_virtual_machine_cdrom_with_http_info(customer_id, cloudspace_id, vm_id, cdrom_id, **kwargs)  # noqa: E501
            return data

    def detach_virtual_machine_cdrom_with_http_info(self, customer_id, cloudspace_id, vm_id, cdrom_id, **kwargs):  # noqa: E501
        """detach_virtual_machine_cdrom  # noqa: E501

        Detach CDROM image from virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.detach_virtual_machine_cdrom_with_http_info(customer_id, cloudspace_id, vm_id, cdrom_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int cdrom_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'cdrom_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method detach_virtual_machine_cdrom" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `detach_virtual_machine_cdrom`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `detach_virtual_machine_cdrom`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `detach_virtual_machine_cdrom`")  # noqa: E501
        # verify the required parameter 'cdrom_id' is set
        if self.api_client.client_side_validation and ('cdrom_id' not in params or
                                                       params['cdrom_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cdrom_id` when calling `detach_virtual_machine_cdrom`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501
        if 'cdrom_id' in params:
            path_params['cdrom_id'] = params['cdrom_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/cdrom-images/{cdrom_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def disable_cloudspace(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """disable_cloudspace  # noqa: E501

        Disable cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_cloudspace(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str reason: Reason for disabling
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.disable_cloudspace_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.disable_cloudspace_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def disable_cloudspace_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """disable_cloudspace  # noqa: E501

        Disable cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_cloudspace_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str reason: Reason for disabling
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'reason', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method disable_cloudspace" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `disable_cloudspace`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `disable_cloudspace`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'reason' in params:
            query_params.append(('reason', params['reason']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/disable', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def disable_customer(self, customer_id, **kwargs):  # noqa: E501
        """disable_customer  # noqa: E501

        Disable Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_customer(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.disable_customer_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.disable_customer_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def disable_customer_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """disable_customer  # noqa: E501

        Disable Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_customer_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method disable_customer" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `disable_customer`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/disable', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def disconnect_objectspace(self, customer_id, cloudspace_id, objectspace_id, **kwargs):  # noqa: E501
        """disconnect_objectspace  # noqa: E501

        Disconnecting objectspace from a cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disconnect_objectspace(customer_id, cloudspace_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str objectspace_id: The objectspace id to be added to the cloudspace (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.disconnect_objectspace_with_http_info(customer_id, cloudspace_id, objectspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.disconnect_objectspace_with_http_info(customer_id, cloudspace_id, objectspace_id, **kwargs)  # noqa: E501
            return data

    def disconnect_objectspace_with_http_info(self, customer_id, cloudspace_id, objectspace_id, **kwargs):  # noqa: E501
        """disconnect_objectspace  # noqa: E501

        Disconnecting objectspace from a cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disconnect_objectspace_with_http_info(customer_id, cloudspace_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str objectspace_id: The objectspace id to be added to the cloudspace (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'objectspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method disconnect_objectspace" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `disconnect_objectspace`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `disconnect_objectspace`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `disconnect_objectspace`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'objectspace_id' in params:
            query_params.append(('objectspace_id', params['objectspace_id']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/objectspaces', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def enable_cloudspace(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """enable_cloudspace  # noqa: E501

        Enable cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_cloudspace(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str reason: Reason for enabling
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.enable_cloudspace_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.enable_cloudspace_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def enable_cloudspace_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """enable_cloudspace  # noqa: E501

        Enable cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_cloudspace_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str reason: Reason for enabling
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'reason', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method enable_cloudspace" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `enable_cloudspace`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `enable_cloudspace`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'reason' in params:
            query_params.append(('reason', params['reason']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/enable', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def enable_customer(self, customer_id, **kwargs):  # noqa: E501
        """enable_customer  # noqa: E501

        Enable Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_customer(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.enable_customer_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.enable_customer_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def enable_customer_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """enable_customer  # noqa: E501

        Enable Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_customer_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method enable_customer" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `enable_customer`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/enable', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def execute_command(self, customer_id, cloudspace_id, vm_id, payload, **kwargs):  # noqa: E501
        """execute_command  # noqa: E501

        Execute command inside virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.execute_command(customer_id, cloudspace_id, vm_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param VMExecuteModel payload: (required)
        :param str x_fields: An optional fields mask
        :return: VmCommandModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.execute_command_with_http_info(customer_id, cloudspace_id, vm_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.execute_command_with_http_info(customer_id, cloudspace_id, vm_id, payload, **kwargs)  # noqa: E501
            return data

    def execute_command_with_http_info(self, customer_id, cloudspace_id, vm_id, payload, **kwargs):  # noqa: E501
        """execute_command  # noqa: E501

        Execute command inside virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.execute_command_with_http_info(customer_id, cloudspace_id, vm_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param VMExecuteModel payload: (required)
        :param str x_fields: An optional fields mask
        :return: VmCommandModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method execute_command" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `execute_command`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `execute_command`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `execute_command`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `execute_command`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/exec', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VmCommandModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def export_virtual_machine_to_s3(self, customer_id, cloudspace_id, vm_id, link, key, secret, region, bucket, object_name, **kwargs):  # noqa: E501
        """export_virtual_machine_to_s3  # noqa: E501

        Export virtual machine to s3  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.export_virtual_machine_to_s3(customer_id, cloudspace_id, vm_id, link, key, secret, region, bucket, object_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str link: S3 server link (required)
        :param str key: access key to the server (required)
        :param str secret: secret to access the server (required)
        :param str region: region of the s3 server (required)
        :param str bucket: Name of the bucket (required)
        :param str object_name: Name of the stored object in the bucker (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.export_virtual_machine_to_s3_with_http_info(customer_id, cloudspace_id, vm_id, link, key, secret, region, bucket, object_name, **kwargs)  # noqa: E501
        else:
            (data) = self.export_virtual_machine_to_s3_with_http_info(customer_id, cloudspace_id, vm_id, link, key, secret, region, bucket, object_name, **kwargs)  # noqa: E501
            return data

    def export_virtual_machine_to_s3_with_http_info(self, customer_id, cloudspace_id, vm_id, link, key, secret, region, bucket, object_name, **kwargs):  # noqa: E501
        """export_virtual_machine_to_s3  # noqa: E501

        Export virtual machine to s3  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.export_virtual_machine_to_s3_with_http_info(customer_id, cloudspace_id, vm_id, link, key, secret, region, bucket, object_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str link: S3 server link (required)
        :param str key: access key to the server (required)
        :param str secret: secret to access the server (required)
        :param str region: region of the s3 server (required)
        :param str bucket: Name of the bucket (required)
        :param str object_name: Name of the stored object in the bucker (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'link', 'key', 'secret', 'region', 'bucket', 'object_name', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method export_virtual_machine_to_s3" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `export_virtual_machine_to_s3`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `export_virtual_machine_to_s3`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `export_virtual_machine_to_s3`")  # noqa: E501
        # verify the required parameter 'link' is set
        if self.api_client.client_side_validation and ('link' not in params or
                                                       params['link'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `link` when calling `export_virtual_machine_to_s3`")  # noqa: E501
        # verify the required parameter 'key' is set
        if self.api_client.client_side_validation and ('key' not in params or
                                                       params['key'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `key` when calling `export_virtual_machine_to_s3`")  # noqa: E501
        # verify the required parameter 'secret' is set
        if self.api_client.client_side_validation and ('secret' not in params or
                                                       params['secret'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `secret` when calling `export_virtual_machine_to_s3`")  # noqa: E501
        # verify the required parameter 'region' is set
        if self.api_client.client_side_validation and ('region' not in params or
                                                       params['region'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `region` when calling `export_virtual_machine_to_s3`")  # noqa: E501
        # verify the required parameter 'bucket' is set
        if self.api_client.client_side_validation and ('bucket' not in params or
                                                       params['bucket'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `bucket` when calling `export_virtual_machine_to_s3`")  # noqa: E501
        # verify the required parameter 'object_name' is set
        if self.api_client.client_side_validation and ('object_name' not in params or
                                                       params['object_name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `object_name` when calling `export_virtual_machine_to_s3`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'link' in params:
            query_params.append(('link', params['link']))  # noqa: E501
        if 'key' in params:
            query_params.append(('key', params['key']))  # noqa: E501
        if 'secret' in params:
            query_params.append(('secret', params['secret']))  # noqa: E501
        if 'region' in params:
            query_params.append(('region', params['region']))  # noqa: E501
        if 'bucket' in params:
            query_params.append(('bucket', params['bucket']))  # noqa: E501
        if 'object_name' in params:
            query_params.append(('object_name', params['object_name']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/export-s3', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def expose_disk(self, customer_id, cloudspace_id, disk_id, **kwargs):  # noqa: E501
        """expose_disk  # noqa: E501

        Expose a disk via the cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.expose_disk(customer_id, cloudspace_id, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int disk_id: Disk ID (required)
        :param int iops: Total number of iops for the disk to be exposed
        :param int max_connections: Maximum number of concurrent connections
        :param str x_fields: An optional fields mask
        :return: ExposeDiskModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.expose_disk_with_http_info(customer_id, cloudspace_id, disk_id, **kwargs)  # noqa: E501
        else:
            (data) = self.expose_disk_with_http_info(customer_id, cloudspace_id, disk_id, **kwargs)  # noqa: E501
            return data

    def expose_disk_with_http_info(self, customer_id, cloudspace_id, disk_id, **kwargs):  # noqa: E501
        """expose_disk  # noqa: E501

        Expose a disk via the cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.expose_disk_with_http_info(customer_id, cloudspace_id, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int disk_id: Disk ID (required)
        :param int iops: Total number of iops for the disk to be exposed
        :param int max_connections: Maximum number of concurrent connections
        :param str x_fields: An optional fields mask
        :return: ExposeDiskModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'disk_id', 'iops', 'max_connections', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method expose_disk" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `expose_disk`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `expose_disk`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `expose_disk`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'disk_id' in params:
            query_params.append(('disk_id', params['disk_id']))  # noqa: E501
        if 'iops' in params:
            query_params.append(('iops', params['iops']))  # noqa: E501
        if 'max_connections' in params:
            query_params.append(('max_connections', params['max_connections']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/exposed-disks', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExposeDiskModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_agent_status(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """get_agent_status  # noqa: E501

        Get virtual machine agent status  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_agent_status(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: GetAgentStatus
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_agent_status_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_agent_status_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def get_agent_status_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """get_agent_status  # noqa: E501

        Get virtual machine agent status  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_agent_status_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: GetAgentStatus
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_agent_status" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_agent_status`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_agent_status`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `get_agent_status`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/agent', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetAgentStatus',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_bucket(self, customer_id, objectspace_id, bucket_id, **kwargs):  # noqa: E501
        """get_bucket  # noqa: E501

        Get the information for a bucket  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_bucket(customer_id, objectspace_id, bucket_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str bucket_id: (required)
        :param str x_fields: An optional fields mask
        :return: GetBucketModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_bucket_with_http_info(customer_id, objectspace_id, bucket_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_bucket_with_http_info(customer_id, objectspace_id, bucket_id, **kwargs)  # noqa: E501
            return data

    def get_bucket_with_http_info(self, customer_id, objectspace_id, bucket_id, **kwargs):  # noqa: E501
        """get_bucket  # noqa: E501

        Get the information for a bucket  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_bucket_with_http_info(customer_id, objectspace_id, bucket_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str bucket_id: (required)
        :param str x_fields: An optional fields mask
        :return: GetBucketModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'objectspace_id', 'bucket_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_bucket" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_bucket`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `get_bucket`")  # noqa: E501
        # verify the required parameter 'bucket_id' is set
        if self.api_client.client_side_validation and ('bucket_id' not in params or
                                                       params['bucket_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `bucket_id` when calling `get_bucket`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'objectspace_id' in params:
            path_params['objectspace_id'] = params['objectspace_id']  # noqa: E501
        if 'bucket_id' in params:
            path_params['bucket_id'] = params['bucket_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces/{objectspace_id}/buckets/{bucket_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetBucketModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_certificate_info(self, customer_id, domain, **kwargs):  # noqa: E501
        """get_certificate_info  # noqa: E501

        Get certificate information  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_certificate_info(customer_id, domain, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str domain: (required)
        :param str x_fields: An optional fields mask
        :return: Certificate
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_certificate_info_with_http_info(customer_id, domain, **kwargs)  # noqa: E501
        else:
            (data) = self.get_certificate_info_with_http_info(customer_id, domain, **kwargs)  # noqa: E501
            return data

    def get_certificate_info_with_http_info(self, customer_id, domain, **kwargs):  # noqa: E501
        """get_certificate_info  # noqa: E501

        Get certificate information  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_certificate_info_with_http_info(customer_id, domain, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str domain: (required)
        :param str x_fields: An optional fields mask
        :return: Certificate
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'domain', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_certificate_info" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_certificate_info`")  # noqa: E501
        # verify the required parameter 'domain' is set
        if self.api_client.client_side_validation and ('domain' not in params or
                                                       params['domain'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `domain` when calling `get_certificate_info`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'domain' in params:
            path_params['domain'] = params['domain']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/certificates/ssl/{domain}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Certificate',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_cloudspace_anti_affinity_group(self, customer_id, cloudspace_id, group_id, **kwargs):  # noqa: E501
        """get_cloudspace_anti_affinity_group  # noqa: E501

        Get anti-affinity group  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_anti_affinity_group(customer_id, cloudspace_id, group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str group_id: (required)
        :param str x_fields: An optional fields mask
        :return: GetCloudspaceAntiAffinityGroupModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_cloudspace_anti_affinity_group_with_http_info(customer_id, cloudspace_id, group_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_cloudspace_anti_affinity_group_with_http_info(customer_id, cloudspace_id, group_id, **kwargs)  # noqa: E501
            return data

    def get_cloudspace_anti_affinity_group_with_http_info(self, customer_id, cloudspace_id, group_id, **kwargs):  # noqa: E501
        """get_cloudspace_anti_affinity_group  # noqa: E501

        Get anti-affinity group  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_anti_affinity_group_with_http_info(customer_id, cloudspace_id, group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str group_id: (required)
        :param str x_fields: An optional fields mask
        :return: GetCloudspaceAntiAffinityGroupModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'group_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_cloudspace_anti_affinity_group" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_cloudspace_anti_affinity_group`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_cloudspace_anti_affinity_group`")  # noqa: E501
        # verify the required parameter 'group_id' is set
        if self.api_client.client_side_validation and ('group_id' not in params or
                                                       params['group_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `group_id` when calling `get_cloudspace_anti_affinity_group`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'group_id' in params:
            path_params['group_id'] = params['group_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/anti-affinity-groups/{group_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetCloudspaceAntiAffinityGroupModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_cloudspace_consumption(self, customer_id, cloudspace_id, end, start, **kwargs):  # noqa: E501
        """get_cloudspace_consumption  # noqa: E501

        Get cloudspace resource consumption  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_consumption(customer_id, cloudspace_id, end, start, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param str x_fields: An optional fields mask
        :return: CloudspaceConsumptionModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_cloudspace_consumption_with_http_info(customer_id, cloudspace_id, end, start, **kwargs)  # noqa: E501
        else:
            (data) = self.get_cloudspace_consumption_with_http_info(customer_id, cloudspace_id, end, start, **kwargs)  # noqa: E501
            return data

    def get_cloudspace_consumption_with_http_info(self, customer_id, cloudspace_id, end, start, **kwargs):  # noqa: E501
        """get_cloudspace_consumption  # noqa: E501

        Get cloudspace resource consumption  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_consumption_with_http_info(customer_id, cloudspace_id, end, start, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param str x_fields: An optional fields mask
        :return: CloudspaceConsumptionModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'end', 'start', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_cloudspace_consumption" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_cloudspace_consumption`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_cloudspace_consumption`")  # noqa: E501
        # verify the required parameter 'end' is set
        if self.api_client.client_side_validation and ('end' not in params or
                                                       params['end'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `end` when calling `get_cloudspace_consumption`")  # noqa: E501
        # verify the required parameter 'start' is set
        if self.api_client.client_side_validation and ('start' not in params or
                                                       params['start'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `start` when calling `get_cloudspace_consumption`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'end' in params:
            query_params.append(('end', params['end']))  # noqa: E501
        if 'start' in params:
            query_params.append(('start', params['start']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/consumption', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CloudspaceConsumptionModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_cloudspace_consumption_series(self, customer_id, cloudspace_id, end, start, step, units, **kwargs):  # noqa: E501
        """get_cloudspace_consumption_series  # noqa: E501

        Get cloudspace resource consumption timeseries  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_consumption_series(customer_id, cloudspace_id, end, start, step, units, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param str step: Step between each time point from [\"15m\", \"30m\", \"60m\", \"24h\"] (required)
        :param list[str] units: List of units to include Possible values: [\"su\", \"tu\", \"nu\", \"vcu\", \"mu\", \"piu\", \"wu\"] (required)
        :param str x_fields: An optional fields mask
        :return: CloudspaceConsumptionTsModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_cloudspace_consumption_series_with_http_info(customer_id, cloudspace_id, end, start, step, units, **kwargs)  # noqa: E501
        else:
            (data) = self.get_cloudspace_consumption_series_with_http_info(customer_id, cloudspace_id, end, start, step, units, **kwargs)  # noqa: E501
            return data

    def get_cloudspace_consumption_series_with_http_info(self, customer_id, cloudspace_id, end, start, step, units, **kwargs):  # noqa: E501
        """get_cloudspace_consumption_series  # noqa: E501

        Get cloudspace resource consumption timeseries  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_consumption_series_with_http_info(customer_id, cloudspace_id, end, start, step, units, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param str step: Step between each time point from [\"15m\", \"30m\", \"60m\", \"24h\"] (required)
        :param list[str] units: List of units to include Possible values: [\"su\", \"tu\", \"nu\", \"vcu\", \"mu\", \"piu\", \"wu\"] (required)
        :param str x_fields: An optional fields mask
        :return: CloudspaceConsumptionTsModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'end', 'start', 'step', 'units', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_cloudspace_consumption_series" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_cloudspace_consumption_series`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_cloudspace_consumption_series`")  # noqa: E501
        # verify the required parameter 'end' is set
        if self.api_client.client_side_validation and ('end' not in params or
                                                       params['end'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `end` when calling `get_cloudspace_consumption_series`")  # noqa: E501
        # verify the required parameter 'start' is set
        if self.api_client.client_side_validation and ('start' not in params or
                                                       params['start'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `start` when calling `get_cloudspace_consumption_series`")  # noqa: E501
        # verify the required parameter 'step' is set
        if self.api_client.client_side_validation and ('step' not in params or
                                                       params['step'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `step` when calling `get_cloudspace_consumption_series`")  # noqa: E501
        # verify the required parameter 'units' is set
        if self.api_client.client_side_validation and ('units' not in params or
                                                       params['units'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `units` when calling `get_cloudspace_consumption_series`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'end' in params:
            query_params.append(('end', params['end']))  # noqa: E501
        if 'start' in params:
            query_params.append(('start', params['start']))  # noqa: E501
        if 'step' in params:
            query_params.append(('step', params['step']))  # noqa: E501
        if 'units' in params:
            query_params.append(('units', params['units']))  # noqa: E501
            collection_formats['units'] = 'csv'  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/consumption/series', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CloudspaceConsumptionTsModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_cloudspace_default_gateway(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """get_cloudspace_default_gateway  # noqa: E501

        Get cloudspace default gateway  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_default_gateway(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: DefaultGateway
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_cloudspace_default_gateway_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_cloudspace_default_gateway_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def get_cloudspace_default_gateway_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """get_cloudspace_default_gateway  # noqa: E501

        Get cloudspace default gateway  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_default_gateway_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: DefaultGateway
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_cloudspace_default_gateway" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_cloudspace_default_gateway`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_cloudspace_default_gateway`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/default-gateway', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DefaultGateway',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_cloudspace_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """get_cloudspace_info  # noqa: E501

        Get cloudspace info  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: CloudspaceInfoModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_cloudspace_info_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_cloudspace_info_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def get_cloudspace_info_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """get_cloudspace_info  # noqa: E501

        Get cloudspace info  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_info_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: CloudspaceInfoModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_cloudspace_info" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_cloudspace_info`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_cloudspace_info`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CloudspaceInfoModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_cloudspace_nested_cloudspaces(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """get_cloudspace_nested_cloudspaces  # noqa: E501

        Get nested cloudspaces  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_nested_cloudspaces(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: CloudspaceChildren
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_cloudspace_nested_cloudspaces_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_cloudspace_nested_cloudspaces_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def get_cloudspace_nested_cloudspaces_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """get_cloudspace_nested_cloudspaces  # noqa: E501

        Get nested cloudspaces  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_nested_cloudspaces_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: CloudspaceChildren
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_cloudspace_nested_cloudspaces" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_cloudspace_nested_cloudspaces`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_cloudspace_nested_cloudspaces`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/nested-cloudspaces', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CloudspaceChildren',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_cloudspace_notes(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """get_cloudspace_notes  # noqa: E501

        Get cloudspace notes  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_notes(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: ResourceNotes
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_cloudspace_notes_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_cloudspace_notes_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def get_cloudspace_notes_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """get_cloudspace_notes  # noqa: E501

        Get cloudspace notes  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_notes_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: ResourceNotes
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_cloudspace_notes" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_cloudspace_notes`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_cloudspace_notes`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/notes', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResourceNotes',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_cloudspace_proxy_config(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """get_cloudspace_proxy_config  # noqa: E501

        Get cloudspace proxy config  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_proxy_config(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: CloudspaceProxyConfigModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_cloudspace_proxy_config_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_cloudspace_proxy_config_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def get_cloudspace_proxy_config_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """get_cloudspace_proxy_config  # noqa: E501

        Get cloudspace proxy config  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_proxy_config_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: CloudspaceProxyConfigModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_cloudspace_proxy_config" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_cloudspace_proxy_config`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_cloudspace_proxy_config`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/proxy-server', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CloudspaceProxyConfigModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_cloudspace_stats(self, customer_id, cloudspace_id, end, start, **kwargs):  # noqa: E501
        """get_cloudspace_stats  # noqa: E501

        Get cloudspace statistics  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_stats(customer_id, cloudspace_id, end, start, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param list[str] include: Cloudspace stats to include. If empty all stats will be returned Fields should be one of the parameters of series object in output model [cpu, network, memory, vdisk_latency,  vdisk_capacity, vdisk_bandwidth, vdisk_iops]
        :param str x_fields: An optional fields mask
        :return: CloudspaceStatsModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_cloudspace_stats_with_http_info(customer_id, cloudspace_id, end, start, **kwargs)  # noqa: E501
        else:
            (data) = self.get_cloudspace_stats_with_http_info(customer_id, cloudspace_id, end, start, **kwargs)  # noqa: E501
            return data

    def get_cloudspace_stats_with_http_info(self, customer_id, cloudspace_id, end, start, **kwargs):  # noqa: E501
        """get_cloudspace_stats  # noqa: E501

        Get cloudspace statistics  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_cloudspace_stats_with_http_info(customer_id, cloudspace_id, end, start, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param list[str] include: Cloudspace stats to include. If empty all stats will be returned Fields should be one of the parameters of series object in output model [cpu, network, memory, vdisk_latency,  vdisk_capacity, vdisk_bandwidth, vdisk_iops]
        :param str x_fields: An optional fields mask
        :return: CloudspaceStatsModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'end', 'start', 'include', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_cloudspace_stats" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_cloudspace_stats`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_cloudspace_stats`")  # noqa: E501
        # verify the required parameter 'end' is set
        if self.api_client.client_side_validation and ('end' not in params or
                                                       params['end'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `end` when calling `get_cloudspace_stats`")  # noqa: E501
        # verify the required parameter 'start' is set
        if self.api_client.client_side_validation and ('start' not in params or
                                                       params['start'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `start` when calling `get_cloudspace_stats`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'end' in params:
            query_params.append(('end', params['end']))  # noqa: E501
        if 'start' in params:
            query_params.append(('start', params['start']))  # noqa: E501
        if 'include' in params:
            query_params.append(('include', params['include']))  # noqa: E501
            collection_formats['include'] = 'csv'  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/statistics', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CloudspaceStatsModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_currencies(self, **kwargs):  # noqa: E501
        """get_currencies  # noqa: E501

        Get Currencies  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_currencies(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_currencies_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.get_currencies_with_http_info(**kwargs)  # noqa: E501
            return data

    def get_currencies_with_http_info(self, **kwargs):  # noqa: E501
        """get_currencies  # noqa: E501

        Get Currencies  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_currencies_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_currencies" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/currencies', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[str]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_customer_compliance_overview(self, **kwargs):  # noqa: E501
        """get_customer_compliance_overview  # noqa: E501

        Returns a list of customers that have compliance issues  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_compliance_overview(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_fields: An optional fields mask
        :return: VCOComplianceReport
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_customer_compliance_overview_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.get_customer_compliance_overview_with_http_info(**kwargs)  # noqa: E501
            return data

    def get_customer_compliance_overview_with_http_info(self, **kwargs):  # noqa: E501
        """get_customer_compliance_overview  # noqa: E501

        Returns a list of customers that have compliance issues  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_compliance_overview_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_fields: An optional fields mask
        :return: VCOComplianceReport
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_customer_compliance_overview" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/compliance', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VCOComplianceReport',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_customer_compliance_report(self, customer_id, **kwargs):  # noqa: E501
        """get_customer_compliance_report  # noqa: E501

        get the information about noncompliant virtual machines in the last 24hr for this Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_compliance_report(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerComplianceReport
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_customer_compliance_report_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_customer_compliance_report_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def get_customer_compliance_report_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """get_customer_compliance_report  # noqa: E501

        get the information about noncompliant virtual machines in the last 24hr for this Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_compliance_report_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerComplianceReport
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_customer_compliance_report" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_customer_compliance_report`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/compliance', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomerComplianceReport',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_customer_compliance_series(self, customer_id, **kwargs):  # noqa: E501
        """get_customer_compliance_series  # noqa: E501

        get the information about licensing issues over time for this Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_compliance_series(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerComplianceSeries
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_customer_compliance_series_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_customer_compliance_series_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def get_customer_compliance_series_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """get_customer_compliance_series  # noqa: E501

        get the information about licensing issues over time for this Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_compliance_series_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerComplianceSeries
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_customer_compliance_series" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_customer_compliance_series`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/statistics/license-compliance', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomerComplianceSeries',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_customer_consumption(self, customer_id, location, end, start, **kwargs):  # noqa: E501
        """get_customer_consumption  # noqa: E501

        get location resource consumption for this Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_consumption(customer_id, location, end, start, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param str x_fields: An optional fields mask
        :return: AccountConsumptionModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_customer_consumption_with_http_info(customer_id, location, end, start, **kwargs)  # noqa: E501
        else:
            (data) = self.get_customer_consumption_with_http_info(customer_id, location, end, start, **kwargs)  # noqa: E501
            return data

    def get_customer_consumption_with_http_info(self, customer_id, location, end, start, **kwargs):  # noqa: E501
        """get_customer_consumption  # noqa: E501

        get location resource consumption for this Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_consumption_with_http_info(customer_id, location, end, start, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param str x_fields: An optional fields mask
        :return: AccountConsumptionModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'end', 'start', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_customer_consumption" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_customer_consumption`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `get_customer_consumption`")  # noqa: E501
        # verify the required parameter 'end' is set
        if self.api_client.client_side_validation and ('end' not in params or
                                                       params['end'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `end` when calling `get_customer_consumption`")  # noqa: E501
        # verify the required parameter 'start' is set
        if self.api_client.client_side_validation and ('start' not in params or
                                                       params['start'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `start` when calling `get_customer_consumption`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501

        query_params = []
        if 'end' in params:
            query_params.append(('end', params['end']))  # noqa: E501
        if 'start' in params:
            query_params.append(('start', params['start']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/consumption', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AccountConsumptionModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_customer_consumption_series(self, customer_id, location, end, start, step, units, **kwargs):  # noqa: E501
        """get_customer_consumption_series  # noqa: E501

        get location resource consumption timeseries for this Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_consumption_series(customer_id, location, end, start, step, units, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param str step: Step between each time point from [\"15m\", \"30m\", \"60m\", \"24h\"] (required)
        :param list[str] units: List of units to include Possible values: [\"su\", \"tu\", \"nu\", \"vcu\", \"mu\", \"piu\", \"wu\", \"ou\"] (required)
        :param str x_fields: An optional fields mask
        :return: AccountConsumptionTsModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_customer_consumption_series_with_http_info(customer_id, location, end, start, step, units, **kwargs)  # noqa: E501
        else:
            (data) = self.get_customer_consumption_series_with_http_info(customer_id, location, end, start, step, units, **kwargs)  # noqa: E501
            return data

    def get_customer_consumption_series_with_http_info(self, customer_id, location, end, start, step, units, **kwargs):  # noqa: E501
        """get_customer_consumption_series  # noqa: E501

        get location resource consumption timeseries for this Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_consumption_series_with_http_info(customer_id, location, end, start, step, units, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param str step: Step between each time point from [\"15m\", \"30m\", \"60m\", \"24h\"] (required)
        :param list[str] units: List of units to include Possible values: [\"su\", \"tu\", \"nu\", \"vcu\", \"mu\", \"piu\", \"wu\", \"ou\"] (required)
        :param str x_fields: An optional fields mask
        :return: AccountConsumptionTsModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'end', 'start', 'step', 'units', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_customer_consumption_series" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_customer_consumption_series`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `get_customer_consumption_series`")  # noqa: E501
        # verify the required parameter 'end' is set
        if self.api_client.client_side_validation and ('end' not in params or
                                                       params['end'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `end` when calling `get_customer_consumption_series`")  # noqa: E501
        # verify the required parameter 'start' is set
        if self.api_client.client_side_validation and ('start' not in params or
                                                       params['start'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `start` when calling `get_customer_consumption_series`")  # noqa: E501
        # verify the required parameter 'step' is set
        if self.api_client.client_side_validation and ('step' not in params or
                                                       params['step'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `step` when calling `get_customer_consumption_series`")  # noqa: E501
        # verify the required parameter 'units' is set
        if self.api_client.client_side_validation and ('units' not in params or
                                                       params['units'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `units` when calling `get_customer_consumption_series`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501

        query_params = []
        if 'end' in params:
            query_params.append(('end', params['end']))  # noqa: E501
        if 'start' in params:
            query_params.append(('start', params['start']))  # noqa: E501
        if 'step' in params:
            query_params.append(('step', params['step']))  # noqa: E501
        if 'units' in params:
            query_params.append(('units', params['units']))  # noqa: E501
            collection_formats['units'] = 'csv'  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/consumption/series', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AccountConsumptionTsModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_customer_info(self, customer_id, **kwargs):  # noqa: E501
        """get_customer_info  # noqa: E501

        Get customer info  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: Customer
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_customer_info_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_customer_info_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def get_customer_info_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """get_customer_info  # noqa: E501

        Get customer info  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_info_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: Customer
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_customer_info" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_customer_info`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Customer',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_customer_invoice_pdf(self, customer_id, invoice_id, **kwargs):  # noqa: E501
        """get_customer_invoice_pdf  # noqa: E501

        Get customer Invoice PDF  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_invoice_pdf(customer_id, invoice_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str invoice_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_customer_invoice_pdf_with_http_info(customer_id, invoice_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_customer_invoice_pdf_with_http_info(customer_id, invoice_id, **kwargs)  # noqa: E501
            return data

    def get_customer_invoice_pdf_with_http_info(self, customer_id, invoice_id, **kwargs):  # noqa: E501
        """get_customer_invoice_pdf  # noqa: E501

        Get customer Invoice PDF  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_invoice_pdf_with_http_info(customer_id, invoice_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str invoice_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'invoice_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_customer_invoice_pdf" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_customer_invoice_pdf`")  # noqa: E501
        # verify the required parameter 'invoice_id' is set
        if self.api_client.client_side_validation and ('invoice_id' not in params or
                                                       params['invoice_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `invoice_id` when calling `get_customer_invoice_pdf`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'invoice_id' in params:
            path_params['invoice_id'] = params['invoice_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/pdf'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/invoices/{invoice_id}/pdf', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_customer_location_capacity(self, customer_id, location, **kwargs):  # noqa: E501
        """get_customer_location_capacity  # noqa: E501

        Get location Capacity  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_location_capacity(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str x_fields: An optional fields mask
        :return: CapacityModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_customer_location_capacity_with_http_info(customer_id, location, **kwargs)  # noqa: E501
        else:
            (data) = self.get_customer_location_capacity_with_http_info(customer_id, location, **kwargs)  # noqa: E501
            return data

    def get_customer_location_capacity_with_http_info(self, customer_id, location, **kwargs):  # noqa: E501
        """get_customer_location_capacity  # noqa: E501

        Get location Capacity  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_location_capacity_with_http_info(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str x_fields: An optional fields mask
        :return: CapacityModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_customer_location_capacity" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_customer_location_capacity`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `get_customer_location_capacity`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/capacity', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CapacityModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_customer_location_datacenter(self, customer_id, location, **kwargs):  # noqa: E501
        """get_customer_location_datacenter  # noqa: E501

        Get customer location datacenter  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_location_datacenter(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str x_fields: An optional fields mask
        :return: Datacenter
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_customer_location_datacenter_with_http_info(customer_id, location, **kwargs)  # noqa: E501
        else:
            (data) = self.get_customer_location_datacenter_with_http_info(customer_id, location, **kwargs)  # noqa: E501
            return data

    def get_customer_location_datacenter_with_http_info(self, customer_id, location, **kwargs):  # noqa: E501
        """get_customer_location_datacenter  # noqa: E501

        Get customer location datacenter  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_location_datacenter_with_http_info(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str x_fields: An optional fields mask
        :return: Datacenter
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_customer_location_datacenter" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_customer_location_datacenter`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `get_customer_location_datacenter`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/datacenter', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Datacenter',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_customer_location_pricing(self, customer_id, location, **kwargs):  # noqa: E501
        """get_customer_location_pricing  # noqa: E501

        Get location prices for this Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_location_pricing(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str x_fields: An optional fields mask
        :return: LocationPricing
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_customer_location_pricing_with_http_info(customer_id, location, **kwargs)  # noqa: E501
        else:
            (data) = self.get_customer_location_pricing_with_http_info(customer_id, location, **kwargs)  # noqa: E501
            return data

    def get_customer_location_pricing_with_http_info(self, customer_id, location, **kwargs):  # noqa: E501
        """get_customer_location_pricing  # noqa: E501

        Get location prices for this Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_location_pricing_with_http_info(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str x_fields: An optional fields mask
        :return: LocationPricing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_customer_location_pricing" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_customer_location_pricing`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `get_customer_location_pricing`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/prices', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='LocationPricing',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_customer_pricing(self, customer_id, **kwargs):  # noqa: E501
        """get_customer_pricing  # noqa: E501

        Get location prices for this Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_pricing(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: VcoPricing
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_customer_pricing_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_customer_pricing_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def get_customer_pricing_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """get_customer_pricing  # noqa: E501

        Get location prices for this Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_customer_pricing_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: VcoPricing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_customer_pricing" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_customer_pricing`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/prices', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VcoPricing',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_disk_consumption(self, customer_id, location, disk_id, end, start, **kwargs):  # noqa: E501
        """get_disk_consumption  # noqa: E501

        Get Disk resource consumption  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_disk_consumption(customer_id, location, disk_id, end, start, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param int end: End timestamp (required)
        :param int start: Start timestamp (required)
        :param str x_fields: An optional fields mask
        :return: DiskConsumptionModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_disk_consumption_with_http_info(customer_id, location, disk_id, end, start, **kwargs)  # noqa: E501
        else:
            (data) = self.get_disk_consumption_with_http_info(customer_id, location, disk_id, end, start, **kwargs)  # noqa: E501
            return data

    def get_disk_consumption_with_http_info(self, customer_id, location, disk_id, end, start, **kwargs):  # noqa: E501
        """get_disk_consumption  # noqa: E501

        Get Disk resource consumption  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_disk_consumption_with_http_info(customer_id, location, disk_id, end, start, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param int end: End timestamp (required)
        :param int start: Start timestamp (required)
        :param str x_fields: An optional fields mask
        :return: DiskConsumptionModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'end', 'start', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_disk_consumption" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_disk_consumption`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `get_disk_consumption`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `get_disk_consumption`")  # noqa: E501
        # verify the required parameter 'end' is set
        if self.api_client.client_side_validation and ('end' not in params or
                                                       params['end'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `end` when calling `get_disk_consumption`")  # noqa: E501
        # verify the required parameter 'start' is set
        if self.api_client.client_side_validation and ('start' not in params or
                                                       params['start'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `start` when calling `get_disk_consumption`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501

        query_params = []
        if 'end' in params:
            query_params.append(('end', params['end']))  # noqa: E501
        if 'start' in params:
            query_params.append(('start', params['start']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/consumption', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DiskConsumptionModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_disk_consumption_series(self, customer_id, location, disk_id, end, start, step, units, **kwargs):  # noqa: E501
        """get_disk_consumption_series  # noqa: E501

        Get Disk resource consumption timeseries  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_disk_consumption_series(customer_id, location, disk_id, end, start, step, units, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param int end: End timestamp (required)
        :param int start: Start timestamp (required)
        :param str step: Step between each time point from [\"15m\", \"30m\", \"60m\", \"24h\"] (required)
        :param list[str] units: List of units to include Possible values: [\"su\", \"tu\"] (required)
        :param str x_fields: An optional fields mask
        :return: DiskTimeseries
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_disk_consumption_series_with_http_info(customer_id, location, disk_id, end, start, step, units, **kwargs)  # noqa: E501
        else:
            (data) = self.get_disk_consumption_series_with_http_info(customer_id, location, disk_id, end, start, step, units, **kwargs)  # noqa: E501
            return data

    def get_disk_consumption_series_with_http_info(self, customer_id, location, disk_id, end, start, step, units, **kwargs):  # noqa: E501
        """get_disk_consumption_series  # noqa: E501

        Get Disk resource consumption timeseries  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_disk_consumption_series_with_http_info(customer_id, location, disk_id, end, start, step, units, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param int end: End timestamp (required)
        :param int start: Start timestamp (required)
        :param str step: Step between each time point from [\"15m\", \"30m\", \"60m\", \"24h\"] (required)
        :param list[str] units: List of units to include Possible values: [\"su\", \"tu\"] (required)
        :param str x_fields: An optional fields mask
        :return: DiskTimeseries
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'end', 'start', 'step', 'units', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_disk_consumption_series" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_disk_consumption_series`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `get_disk_consumption_series`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `get_disk_consumption_series`")  # noqa: E501
        # verify the required parameter 'end' is set
        if self.api_client.client_side_validation and ('end' not in params or
                                                       params['end'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `end` when calling `get_disk_consumption_series`")  # noqa: E501
        # verify the required parameter 'start' is set
        if self.api_client.client_side_validation and ('start' not in params or
                                                       params['start'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `start` when calling `get_disk_consumption_series`")  # noqa: E501
        # verify the required parameter 'step' is set
        if self.api_client.client_side_validation and ('step' not in params or
                                                       params['step'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `step` when calling `get_disk_consumption_series`")  # noqa: E501
        # verify the required parameter 'units' is set
        if self.api_client.client_side_validation and ('units' not in params or
                                                       params['units'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `units` when calling `get_disk_consumption_series`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501

        query_params = []
        if 'end' in params:
            query_params.append(('end', params['end']))  # noqa: E501
        if 'start' in params:
            query_params.append(('start', params['start']))  # noqa: E501
        if 'step' in params:
            query_params.append(('step', params['step']))  # noqa: E501
        if 'units' in params:
            query_params.append(('units', params['units']))  # noqa: E501
            collection_formats['units'] = 'csv'  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/consumption/series', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DiskTimeseries',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_disk_info(self, customer_id, location, disk_id, **kwargs):  # noqa: E501
        """get_disk_info  # noqa: E501

        Get disk Information  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_disk_info(customer_id, location, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str x_fields: An optional fields mask
        :return: DiskModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_disk_info_with_http_info(customer_id, location, disk_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_disk_info_with_http_info(customer_id, location, disk_id, **kwargs)  # noqa: E501
            return data

    def get_disk_info_with_http_info(self, customer_id, location, disk_id, **kwargs):  # noqa: E501
        """get_disk_info  # noqa: E501

        Get disk Information  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_disk_info_with_http_info(customer_id, location, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str x_fields: An optional fields mask
        :return: DiskModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_disk_info" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_disk_info`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `get_disk_info`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `get_disk_info`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DiskModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_disk_notes(self, customer_id, location, disk_id, **kwargs):  # noqa: E501
        """get_disk_notes  # noqa: E501

        Get disk notes  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_disk_notes(customer_id, location, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str x_fields: An optional fields mask
        :return: ResourceNotes
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_disk_notes_with_http_info(customer_id, location, disk_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_disk_notes_with_http_info(customer_id, location, disk_id, **kwargs)  # noqa: E501
            return data

    def get_disk_notes_with_http_info(self, customer_id, location, disk_id, **kwargs):  # noqa: E501
        """get_disk_notes  # noqa: E501

        Get disk notes  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_disk_notes_with_http_info(customer_id, location, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str x_fields: An optional fields mask
        :return: ResourceNotes
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_disk_notes" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_disk_notes`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `get_disk_notes`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `get_disk_notes`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/notes', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResourceNotes',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_disk_snapshot(self, customer_id, location, disk_id, snapshot_id, **kwargs):  # noqa: E501
        """get_disk_snapshot  # noqa: E501

        Get Disk snapshot  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_disk_snapshot(customer_id, location, disk_id, snapshot_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str snapshot_id: (required)
        :param bool all_vm_disks: List disks have the same snapshot ID
        :param str x_fields: An optional fields mask
        :return: DiskSnapshotModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_disk_snapshot_with_http_info(customer_id, location, disk_id, snapshot_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_disk_snapshot_with_http_info(customer_id, location, disk_id, snapshot_id, **kwargs)  # noqa: E501
            return data

    def get_disk_snapshot_with_http_info(self, customer_id, location, disk_id, snapshot_id, **kwargs):  # noqa: E501
        """get_disk_snapshot  # noqa: E501

        Get Disk snapshot  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_disk_snapshot_with_http_info(customer_id, location, disk_id, snapshot_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str snapshot_id: (required)
        :param bool all_vm_disks: List disks have the same snapshot ID
        :param str x_fields: An optional fields mask
        :return: DiskSnapshotModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'snapshot_id', 'all_vm_disks', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_disk_snapshot" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `get_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `get_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'snapshot_id' is set
        if self.api_client.client_side_validation and ('snapshot_id' not in params or
                                                       params['snapshot_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `snapshot_id` when calling `get_disk_snapshot`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501
        if 'snapshot_id' in params:
            path_params['snapshot_id'] = params['snapshot_id']  # noqa: E501

        query_params = []
        if 'all_vm_disks' in params:
            query_params.append(('all_vm_disks', params['all_vm_disks']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/snapshots/{snapshot_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DiskSnapshotModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_external_network(self, customer_id, location, external_network_id, **kwargs):  # noqa: E501
        """get_external_network  # noqa: E501

        Get external network info  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_external_network(customer_id, location, external_network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int external_network_id: (required)
        :param str x_fields: An optional fields mask
        :return: ExternalNetworkModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_external_network_with_http_info(customer_id, location, external_network_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_external_network_with_http_info(customer_id, location, external_network_id, **kwargs)  # noqa: E501
            return data

    def get_external_network_with_http_info(self, customer_id, location, external_network_id, **kwargs):  # noqa: E501
        """get_external_network  # noqa: E501

        Get external network info  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_external_network_with_http_info(customer_id, location, external_network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int external_network_id: (required)
        :param str x_fields: An optional fields mask
        :return: ExternalNetworkModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'external_network_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_external_network" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_external_network`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `get_external_network`")  # noqa: E501
        # verify the required parameter 'external_network_id' is set
        if self.api_client.client_side_validation and ('external_network_id' not in params or
                                                       params['external_network_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `external_network_id` when calling `get_external_network`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'external_network_id' in params:
            path_params['external_network_id'] = params['external_network_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/external-networks/{external_network_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExternalNetworkModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_external_networks_virtual_machine(self, customer_id, cloudspace_id, vm_id, external_ip_address, **kwargs):  # noqa: E501
        """get_external_networks_virtual_machine  # noqa: E501

        Get external network (NIC) that the virtual machine is attached to  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_external_networks_virtual_machine(customer_id, cloudspace_id, vm_id, external_ip_address, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str external_ip_address: (required)
        :param str x_fields: An optional fields mask
        :return: ExternalNIC
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_external_networks_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, external_ip_address, **kwargs)  # noqa: E501
        else:
            (data) = self.get_external_networks_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, external_ip_address, **kwargs)  # noqa: E501
            return data

    def get_external_networks_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, external_ip_address, **kwargs):  # noqa: E501
        """get_external_networks_virtual_machine  # noqa: E501

        Get external network (NIC) that the virtual machine is attached to  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_external_networks_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, external_ip_address, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str external_ip_address: (required)
        :param str x_fields: An optional fields mask
        :return: ExternalNIC
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'external_ip_address', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_external_networks_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_external_networks_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_external_networks_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `get_external_networks_virtual_machine`")  # noqa: E501
        # verify the required parameter 'external_ip_address' is set
        if self.api_client.client_side_validation and ('external_ip_address' not in params or
                                                       params['external_ip_address'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `external_ip_address` when calling `get_external_networks_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501
        if 'external_ip_address' in params:
            path_params['external_ip_address'] = params['external_ip_address']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/external-nics/{external_ip_address}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExternalNIC',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_image(self, customer_id, location, image_id, **kwargs):  # noqa: E501
        """get_image  # noqa: E501

        Get image details  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_image(customer_id, location, image_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int image_id: (required)
        :param str x_fields: An optional fields mask
        :return: ImageModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_image_with_http_info(customer_id, location, image_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_image_with_http_info(customer_id, location, image_id, **kwargs)  # noqa: E501
            return data

    def get_image_with_http_info(self, customer_id, location, image_id, **kwargs):  # noqa: E501
        """get_image  # noqa: E501

        Get image details  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_image_with_http_info(customer_id, location, image_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int image_id: (required)
        :param str x_fields: An optional fields mask
        :return: ImageModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'image_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_image" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_image`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `get_image`")  # noqa: E501
        # verify the required parameter 'image_id' is set
        if self.api_client.client_side_validation and ('image_id' not in params or
                                                       params['image_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `image_id` when calling `get_image`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'image_id' in params:
            path_params['image_id'] = params['image_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/vm-images/{image_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ImageModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_objectspace(self, customer_id, objectspace_id, **kwargs):  # noqa: E501
        """get_objectspace  # noqa: E501

        Get the details of an objectspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_objectspace(customer_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: GetObjectspaceModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_objectspace_with_http_info(customer_id, objectspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_objectspace_with_http_info(customer_id, objectspace_id, **kwargs)  # noqa: E501
            return data

    def get_objectspace_with_http_info(self, customer_id, objectspace_id, **kwargs):  # noqa: E501
        """get_objectspace  # noqa: E501

        Get the details of an objectspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_objectspace_with_http_info(customer_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: GetObjectspaceModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'objectspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_objectspace" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_objectspace`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `get_objectspace`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'objectspace_id' in params:
            path_params['objectspace_id'] = params['objectspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces/{objectspace_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetObjectspaceModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_objectspace_notes(self, customer_id, objectspace_id, **kwargs):  # noqa: E501
        """get_objectspace_notes  # noqa: E501

        Get objectspace notes  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_objectspace_notes(customer_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: ResourceNotes
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_objectspace_notes_with_http_info(customer_id, objectspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_objectspace_notes_with_http_info(customer_id, objectspace_id, **kwargs)  # noqa: E501
            return data

    def get_objectspace_notes_with_http_info(self, customer_id, objectspace_id, **kwargs):  # noqa: E501
        """get_objectspace_notes  # noqa: E501

        Get objectspace notes  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_objectspace_notes_with_http_info(customer_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: ResourceNotes
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'objectspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_objectspace_notes" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_objectspace_notes`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `get_objectspace_notes`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'objectspace_id' in params:
            path_params['objectspace_id'] = params['objectspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces/{objectspace_id}/notes', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResourceNotes',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_os_names(self, **kwargs):  # noqa: E501
        """get_os_names  # noqa: E501

        Get supported OS names  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_os_names(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_fields: An optional fields mask
        :return: OSNamesMap
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_os_names_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.get_os_names_with_http_info(**kwargs)  # noqa: E501
            return data

    def get_os_names_with_http_info(self, **kwargs):  # noqa: E501
        """get_os_names  # noqa: E501

        Get supported OS names  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_os_names_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_fields: An optional fields mask
        :return: OSNamesMap
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_os_names" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/vm-images/os-names', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='OSNamesMap',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_os_types(self, **kwargs):  # noqa: E501
        """get_os_types  # noqa: E501

        Get OS types  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_os_types(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_os_types_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.get_os_types_with_http_info(**kwargs)  # noqa: E501
            return data

    def get_os_types_with_http_info(self, **kwargs):  # noqa: E501
        """get_os_types  # noqa: E501

        Get OS types  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_os_types_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_os_types" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/vm-images/os-types', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_portforward(self, customer_id, cloudspace_id, portforward_id, **kwargs):  # noqa: E501
        """get_portforward  # noqa: E501

        Get cloudspace port forward  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_portforward(customer_id, cloudspace_id, portforward_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str portforward_id: (required)
        :param str x_fields: An optional fields mask
        :return: PortforwardsModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_portforward_with_http_info(customer_id, cloudspace_id, portforward_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_portforward_with_http_info(customer_id, cloudspace_id, portforward_id, **kwargs)  # noqa: E501
            return data

    def get_portforward_with_http_info(self, customer_id, cloudspace_id, portforward_id, **kwargs):  # noqa: E501
        """get_portforward  # noqa: E501

        Get cloudspace port forward  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_portforward_with_http_info(customer_id, cloudspace_id, portforward_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str portforward_id: (required)
        :param str x_fields: An optional fields mask
        :return: PortforwardsModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'portforward_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_portforward" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_portforward`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_portforward`")  # noqa: E501
        # verify the required parameter 'portforward_id' is set
        if self.api_client.client_side_validation and ('portforward_id' not in params or
                                                       params['portforward_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `portforward_id` when calling `get_portforward`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'portforward_id' in params:
            path_params['portforward_id'] = params['portforward_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/portforwards/{portforward_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PortforwardsModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_remote_cloudspace_connection_status(self, customer_id, cloudspace_id, connected_cloudspace_id, **kwargs):  # noqa: E501
        """get_remote_cloudspace_connection_status  # noqa: E501

        Get remote connection status  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_remote_cloudspace_connection_status(customer_id, cloudspace_id, connected_cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str connected_cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: RemoteConnectionStatus
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_remote_cloudspace_connection_status_with_http_info(customer_id, cloudspace_id, connected_cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_remote_cloudspace_connection_status_with_http_info(customer_id, cloudspace_id, connected_cloudspace_id, **kwargs)  # noqa: E501
            return data

    def get_remote_cloudspace_connection_status_with_http_info(self, customer_id, cloudspace_id, connected_cloudspace_id, **kwargs):  # noqa: E501
        """get_remote_cloudspace_connection_status  # noqa: E501

        Get remote connection status  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_remote_cloudspace_connection_status_with_http_info(customer_id, cloudspace_id, connected_cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str connected_cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: RemoteConnectionStatus
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'connected_cloudspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_remote_cloudspace_connection_status" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_remote_cloudspace_connection_status`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_remote_cloudspace_connection_status`")  # noqa: E501
        # verify the required parameter 'connected_cloudspace_id' is set
        if self.api_client.client_side_validation and ('connected_cloudspace_id' not in params or
                                                       params['connected_cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `connected_cloudspace_id` when calling `get_remote_cloudspace_connection_status`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'connected_cloudspace_id' in params:
            path_params['connected_cloudspace_id'] = params['connected_cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/connected-cloudspaces/{connected_cloudspace_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='RemoteConnectionStatus',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_role(self, customer_id, role_id, **kwargs):  # noqa: E501
        """get_role  # noqa: E501

        Get customer role  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_role(customer_id, role_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str role_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRoleFull
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_role_with_http_info(customer_id, role_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_role_with_http_info(customer_id, role_id, **kwargs)  # noqa: E501
            return data

    def get_role_with_http_info(self, customer_id, role_id, **kwargs):  # noqa: E501
        """get_role  # noqa: E501

        Get customer role  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_role_with_http_info(customer_id, role_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str role_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRoleFull
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'role_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_role" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_role`")  # noqa: E501
        # verify the required parameter 'role_id' is set
        if self.api_client.client_side_validation and ('role_id' not in params or
                                                       params['role_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `role_id` when calling `get_role`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'role_id' in params:
            path_params['role_id'] = params['role_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/roles/{role_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomerRoleFull',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_support_access(self, customer_id, **kwargs):  # noqa: E501
        """get_support_access  # noqa: E501

        get support organization access  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_support_access(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_support_access_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_support_access_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def get_support_access_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """get_support_access  # noqa: E501

        get support organization access  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_support_access_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_support_access" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_support_access`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/support-access', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_virtual_machine_anti_affinity_groups(self, customer_id, cloudspace_id, group_id, **kwargs):  # noqa: E501
        """get_virtual_machine_anti_affinity_groups  # noqa: E501

        Get virtual machine anti-affinity groups  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtual_machine_anti_affinity_groups(customer_id, cloudspace_id, group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str group_id: (required)
        :param str x_fields: An optional fields mask
        :return: GetCloudspaceAntiAffinityGroupVmsModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_virtual_machine_anti_affinity_groups_with_http_info(customer_id, cloudspace_id, group_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_virtual_machine_anti_affinity_groups_with_http_info(customer_id, cloudspace_id, group_id, **kwargs)  # noqa: E501
            return data

    def get_virtual_machine_anti_affinity_groups_with_http_info(self, customer_id, cloudspace_id, group_id, **kwargs):  # noqa: E501
        """get_virtual_machine_anti_affinity_groups  # noqa: E501

        Get virtual machine anti-affinity groups  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtual_machine_anti_affinity_groups_with_http_info(customer_id, cloudspace_id, group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str group_id: (required)
        :param str x_fields: An optional fields mask
        :return: GetCloudspaceAntiAffinityGroupVmsModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'group_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_virtual_machine_anti_affinity_groups" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_virtual_machine_anti_affinity_groups`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_virtual_machine_anti_affinity_groups`")  # noqa: E501
        # verify the required parameter 'group_id' is set
        if self.api_client.client_side_validation and ('group_id' not in params or
                                                       params['group_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `group_id` when calling `get_virtual_machine_anti_affinity_groups`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'group_id' in params:
            path_params['group_id'] = params['group_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/anti-affinity-groups/{group_id}/vms', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GetCloudspaceAntiAffinityGroupVmsModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_virtual_machine_console(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """get_virtual_machine_console  # noqa: E501

        Get virtual machine console  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtual_machine_console(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_virtual_machine_console_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_virtual_machine_console_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def get_virtual_machine_console_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """get_virtual_machine_console  # noqa: E501

        Get virtual machine console  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtual_machine_console_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_virtual_machine_console" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_virtual_machine_console`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_virtual_machine_console`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `get_virtual_machine_console`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/console', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_virtual_machine_consumption(self, customer_id, cloudspace_id, vm_id, end, start, **kwargs):  # noqa: E501
        """get_virtual_machine_consumption  # noqa: E501

        Get virtual machine resource consumption  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtual_machine_consumption(customer_id, cloudspace_id, vm_id, end, start, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param str x_fields: An optional fields mask
        :return: VmConsumptionModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_virtual_machine_consumption_with_http_info(customer_id, cloudspace_id, vm_id, end, start, **kwargs)  # noqa: E501
        else:
            (data) = self.get_virtual_machine_consumption_with_http_info(customer_id, cloudspace_id, vm_id, end, start, **kwargs)  # noqa: E501
            return data

    def get_virtual_machine_consumption_with_http_info(self, customer_id, cloudspace_id, vm_id, end, start, **kwargs):  # noqa: E501
        """get_virtual_machine_consumption  # noqa: E501

        Get virtual machine resource consumption  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtual_machine_consumption_with_http_info(customer_id, cloudspace_id, vm_id, end, start, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param str x_fields: An optional fields mask
        :return: VmConsumptionModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'end', 'start', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_virtual_machine_consumption" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_virtual_machine_consumption`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_virtual_machine_consumption`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `get_virtual_machine_consumption`")  # noqa: E501
        # verify the required parameter 'end' is set
        if self.api_client.client_side_validation and ('end' not in params or
                                                       params['end'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `end` when calling `get_virtual_machine_consumption`")  # noqa: E501
        # verify the required parameter 'start' is set
        if self.api_client.client_side_validation and ('start' not in params or
                                                       params['start'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `start` when calling `get_virtual_machine_consumption`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'end' in params:
            query_params.append(('end', params['end']))  # noqa: E501
        if 'start' in params:
            query_params.append(('start', params['start']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/consumption', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VmConsumptionModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_virtual_machine_consumption_series(self, customer_id, cloudspace_id, vm_id, end, start, step, units, **kwargs):  # noqa: E501
        """get_virtual_machine_consumption_series  # noqa: E501

        Get virtual machine resource consumption timeseries  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtual_machine_consumption_series(customer_id, cloudspace_id, vm_id, end, start, step, units, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param str step: Step between each time point from [\"15m\", \"30m\", \"60m\", \"24h\"] (required)
        :param list[str] units: List of units to include Possible values: [\"su\", \"tu\", \"nu\", \"vcu\", \"mu\", \"piu\", \"wu\"] (required)
        :param str x_fields: An optional fields mask
        :return: VmConsumptionTsModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_virtual_machine_consumption_series_with_http_info(customer_id, cloudspace_id, vm_id, end, start, step, units, **kwargs)  # noqa: E501
        else:
            (data) = self.get_virtual_machine_consumption_series_with_http_info(customer_id, cloudspace_id, vm_id, end, start, step, units, **kwargs)  # noqa: E501
            return data

    def get_virtual_machine_consumption_series_with_http_info(self, customer_id, cloudspace_id, vm_id, end, start, step, units, **kwargs):  # noqa: E501
        """get_virtual_machine_consumption_series  # noqa: E501

        Get virtual machine resource consumption timeseries  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtual_machine_consumption_series_with_http_info(customer_id, cloudspace_id, vm_id, end, start, step, units, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param str step: Step between each time point from [\"15m\", \"30m\", \"60m\", \"24h\"] (required)
        :param list[str] units: List of units to include Possible values: [\"su\", \"tu\", \"nu\", \"vcu\", \"mu\", \"piu\", \"wu\"] (required)
        :param str x_fields: An optional fields mask
        :return: VmConsumptionTsModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'end', 'start', 'step', 'units', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_virtual_machine_consumption_series" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_virtual_machine_consumption_series`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_virtual_machine_consumption_series`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `get_virtual_machine_consumption_series`")  # noqa: E501
        # verify the required parameter 'end' is set
        if self.api_client.client_side_validation and ('end' not in params or
                                                       params['end'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `end` when calling `get_virtual_machine_consumption_series`")  # noqa: E501
        # verify the required parameter 'start' is set
        if self.api_client.client_side_validation and ('start' not in params or
                                                       params['start'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `start` when calling `get_virtual_machine_consumption_series`")  # noqa: E501
        # verify the required parameter 'step' is set
        if self.api_client.client_side_validation and ('step' not in params or
                                                       params['step'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `step` when calling `get_virtual_machine_consumption_series`")  # noqa: E501
        # verify the required parameter 'units' is set
        if self.api_client.client_side_validation and ('units' not in params or
                                                       params['units'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `units` when calling `get_virtual_machine_consumption_series`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'end' in params:
            query_params.append(('end', params['end']))  # noqa: E501
        if 'start' in params:
            query_params.append(('start', params['start']))  # noqa: E501
        if 'step' in params:
            query_params.append(('step', params['step']))  # noqa: E501
        if 'units' in params:
            query_params.append(('units', params['units']))  # noqa: E501
            collection_formats['units'] = 'csv'  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/consumption/series', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VmConsumptionTsModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_virtual_machine_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """get_virtual_machine_info  # noqa: E501

        Get virtual machine info  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtual_machine_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: VmInfoModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_virtual_machine_info_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_virtual_machine_info_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def get_virtual_machine_info_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """get_virtual_machine_info  # noqa: E501

        Get virtual machine info  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtual_machine_info_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: VmInfoModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_virtual_machine_info" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_virtual_machine_info`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_virtual_machine_info`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `get_virtual_machine_info`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VmInfoModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_virtual_machine_notes(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """get_virtual_machine_notes  # noqa: E501

        Get virtual machine notes  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtual_machine_notes(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: ResourceNotes
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_virtual_machine_notes_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_virtual_machine_notes_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def get_virtual_machine_notes_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """get_virtual_machine_notes  # noqa: E501

        Get virtual machine notes  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtual_machine_notes_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: ResourceNotes
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_virtual_machine_notes" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_virtual_machine_notes`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_virtual_machine_notes`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `get_virtual_machine_notes`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/notes', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResourceNotes',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_virtual_machine_stats(self, customer_id, cloudspace_id, vm_id, end, start, **kwargs):  # noqa: E501
        """get_virtual_machine_stats  # noqa: E501

        Get Virtual Machine Statistics  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtual_machine_stats(customer_id, cloudspace_id, vm_id, end, start, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param list[str] include: Virtual machines stats to include. If empty all stats will be returned Fields should be one of the parameters of series object in output model [cpu, network, memory, vm_capacity, vm_latency, vm_iops, vm_bandwidth, vdisk_latency, vdisk_capacity, vdisk_bandwidth, vdisk_iops]
        :param str x_fields: An optional fields mask
        :return: VmStatsModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_virtual_machine_stats_with_http_info(customer_id, cloudspace_id, vm_id, end, start, **kwargs)  # noqa: E501
        else:
            (data) = self.get_virtual_machine_stats_with_http_info(customer_id, cloudspace_id, vm_id, end, start, **kwargs)  # noqa: E501
            return data

    def get_virtual_machine_stats_with_http_info(self, customer_id, cloudspace_id, vm_id, end, start, **kwargs):  # noqa: E501
        """get_virtual_machine_stats  # noqa: E501

        Get Virtual Machine Statistics  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtual_machine_stats_with_http_info(customer_id, cloudspace_id, vm_id, end, start, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int end: End timestamp presented as a unix timestamp in seconds (required)
        :param int start: Start timestamp presented as a unix timestamp in seconds (required)
        :param list[str] include: Virtual machines stats to include. If empty all stats will be returned Fields should be one of the parameters of series object in output model [cpu, network, memory, vm_capacity, vm_latency, vm_iops, vm_bandwidth, vdisk_latency, vdisk_capacity, vdisk_bandwidth, vdisk_iops]
        :param str x_fields: An optional fields mask
        :return: VmStatsModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'end', 'start', 'include', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_virtual_machine_stats" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_virtual_machine_stats`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_virtual_machine_stats`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `get_virtual_machine_stats`")  # noqa: E501
        # verify the required parameter 'end' is set
        if self.api_client.client_side_validation and ('end' not in params or
                                                       params['end'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `end` when calling `get_virtual_machine_stats`")  # noqa: E501
        # verify the required parameter 'start' is set
        if self.api_client.client_side_validation and ('start' not in params or
                                                       params['start'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `start` when calling `get_virtual_machine_stats`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'end' in params:
            query_params.append(('end', params['end']))  # noqa: E501
        if 'start' in params:
            query_params.append(('start', params['start']))  # noqa: E501
        if 'include' in params:
            query_params.append(('include', params['include']))  # noqa: E501
            collection_formats['include'] = 'csv'  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/statistics', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VmStatsModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_vm_price_simulation(self, customer_id, location, memory, vcpus, disksize, iops, is_windows_vm, **kwargs):  # noqa: E501
        """get_vm_price_simulation  # noqa: E501

        get estimated VM price per month  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_vm_price_simulation(customer_id, location, memory, vcpus, disksize, iops, is_windows_vm, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int memory: Amount of memory in MiB (required)
        :param int vcpus: Number of VCPUs (required)
        :param int disksize: Total disk size in GiB (required)
        :param int iops: IOPS of the bootdisk (required)
        :param bool is_windows_vm: Indicates if VM requires Windows license (required)
        :param str x_fields: An optional fields mask
        :return: VMPrice
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_vm_price_simulation_with_http_info(customer_id, location, memory, vcpus, disksize, iops, is_windows_vm, **kwargs)  # noqa: E501
        else:
            (data) = self.get_vm_price_simulation_with_http_info(customer_id, location, memory, vcpus, disksize, iops, is_windows_vm, **kwargs)  # noqa: E501
            return data

    def get_vm_price_simulation_with_http_info(self, customer_id, location, memory, vcpus, disksize, iops, is_windows_vm, **kwargs):  # noqa: E501
        """get_vm_price_simulation  # noqa: E501

        get estimated VM price per month  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_vm_price_simulation_with_http_info(customer_id, location, memory, vcpus, disksize, iops, is_windows_vm, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int memory: Amount of memory in MiB (required)
        :param int vcpus: Number of VCPUs (required)
        :param int disksize: Total disk size in GiB (required)
        :param int iops: IOPS of the bootdisk (required)
        :param bool is_windows_vm: Indicates if VM requires Windows license (required)
        :param str x_fields: An optional fields mask
        :return: VMPrice
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'memory', 'vcpus', 'disksize', 'iops', 'is_windows_vm', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_vm_price_simulation" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_vm_price_simulation`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `get_vm_price_simulation`")  # noqa: E501
        # verify the required parameter 'memory' is set
        if self.api_client.client_side_validation and ('memory' not in params or
                                                       params['memory'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `memory` when calling `get_vm_price_simulation`")  # noqa: E501
        # verify the required parameter 'vcpus' is set
        if self.api_client.client_side_validation and ('vcpus' not in params or
                                                       params['vcpus'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vcpus` when calling `get_vm_price_simulation`")  # noqa: E501
        # verify the required parameter 'disksize' is set
        if self.api_client.client_side_validation and ('disksize' not in params or
                                                       params['disksize'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disksize` when calling `get_vm_price_simulation`")  # noqa: E501
        # verify the required parameter 'iops' is set
        if self.api_client.client_side_validation and ('iops' not in params or
                                                       params['iops'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `iops` when calling `get_vm_price_simulation`")  # noqa: E501
        # verify the required parameter 'is_windows_vm' is set
        if self.api_client.client_side_validation and ('is_windows_vm' not in params or
                                                       params['is_windows_vm'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `is_windows_vm` when calling `get_vm_price_simulation`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501

        query_params = []
        if 'memory' in params:
            query_params.append(('memory', params['memory']))  # noqa: E501
        if 'vcpus' in params:
            query_params.append(('vcpus', params['vcpus']))  # noqa: E501
        if 'disksize' in params:
            query_params.append(('disksize', params['disksize']))  # noqa: E501
        if 'iops' in params:
            query_params.append(('iops', params['iops']))  # noqa: E501
        if 'is_windows_vm' in params:
            query_params.append(('is_windows_vm', params['is_windows_vm']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/vm-price-simulation', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VMPrice',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_vmcdrom_info(self, customer_id, cloudspace_id, vm_id, cdrom_id, **kwargs):  # noqa: E501
        """get_vmcdrom_info  # noqa: E501

        Get virtual machine attached CDROM image Info  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_vmcdrom_info(customer_id, cloudspace_id, vm_id, cdrom_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int cdrom_id: (required)
        :param str x_fields: An optional fields mask
        :return: CDROMModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_vmcdrom_info_with_http_info(customer_id, cloudspace_id, vm_id, cdrom_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_vmcdrom_info_with_http_info(customer_id, cloudspace_id, vm_id, cdrom_id, **kwargs)  # noqa: E501
            return data

    def get_vmcdrom_info_with_http_info(self, customer_id, cloudspace_id, vm_id, cdrom_id, **kwargs):  # noqa: E501
        """get_vmcdrom_info  # noqa: E501

        Get virtual machine attached CDROM image Info  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_vmcdrom_info_with_http_info(customer_id, cloudspace_id, vm_id, cdrom_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int cdrom_id: (required)
        :param str x_fields: An optional fields mask
        :return: CDROMModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'cdrom_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_vmcdrom_info" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `get_vmcdrom_info`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `get_vmcdrom_info`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `get_vmcdrom_info`")  # noqa: E501
        # verify the required parameter 'cdrom_id' is set
        if self.api_client.client_side_validation and ('cdrom_id' not in params or
                                                       params['cdrom_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cdrom_id` when calling `get_vmcdrom_info`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501
        if 'cdrom_id' in params:
            path_params['cdrom_id'] = params['cdrom_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/cdrom-images/{cdrom_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CDROMModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_buckets(self, customer_id, objectspace_id, **kwargs):  # noqa: E501
        """list_buckets  # noqa: E501

        List all of the buckets connected to the objectspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_buckets(customer_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param bool include_deleted: optionally return soft-deleted buckets
        :param bool only_deleted: Only include deleted buckets
        :param str x_fields: An optional fields mask
        :return: Buckets
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_buckets_with_http_info(customer_id, objectspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_buckets_with_http_info(customer_id, objectspace_id, **kwargs)  # noqa: E501
            return data

    def list_buckets_with_http_info(self, customer_id, objectspace_id, **kwargs):  # noqa: E501
        """list_buckets  # noqa: E501

        List all of the buckets connected to the objectspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_buckets_with_http_info(customer_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param bool include_deleted: optionally return soft-deleted buckets
        :param bool only_deleted: Only include deleted buckets
        :param str x_fields: An optional fields mask
        :return: Buckets
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'objectspace_id', 'include_deleted', 'only_deleted', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_buckets" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_buckets`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `list_buckets`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'objectspace_id' in params:
            path_params['objectspace_id'] = params['objectspace_id']  # noqa: E501

        query_params = []
        if 'include_deleted' in params:
            query_params.append(('include_deleted', params['include_deleted']))  # noqa: E501
        if 'only_deleted' in params:
            query_params.append(('only_deleted', params['only_deleted']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces/{objectspace_id}/buckets', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Buckets',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_cloudspace_anti_affinity_groups(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_cloudspace_anti_affinity_groups  # noqa: E501

        List anti-affinity groups  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_cloudspace_anti_affinity_groups(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: AntiAffinityGroups
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_cloudspace_anti_affinity_groups_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_cloudspace_anti_affinity_groups_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def list_cloudspace_anti_affinity_groups_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_cloudspace_anti_affinity_groups  # noqa: E501

        List anti-affinity groups  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_cloudspace_anti_affinity_groups_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: AntiAffinityGroups
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_cloudspace_anti_affinity_groups" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_cloudspace_anti_affinity_groups`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `list_cloudspace_anti_affinity_groups`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/anti-affinity-groups', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AntiAffinityGroups',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_cloudspace_external_networks(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_cloudspace_external_networks  # noqa: E501

        List cloudspace external networks  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_cloudspace_external_networks(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_cloudspace_external_networks_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_cloudspace_external_networks_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def list_cloudspace_external_networks_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_cloudspace_external_networks  # noqa: E501

        List cloudspace external networks  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_cloudspace_external_networks_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_cloudspace_external_networks" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_cloudspace_external_networks`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `list_cloudspace_external_networks`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/external-network', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_cloudspace_network_routes(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_cloudspace_network_routes  # noqa: E501

        List cloud space routes  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_cloudspace_network_routes(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_cloudspace_network_routes_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_cloudspace_network_routes_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def list_cloudspace_network_routes_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_cloudspace_network_routes  # noqa: E501

        List cloud space routes  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_cloudspace_network_routes_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_cloudspace_network_routes" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_cloudspace_network_routes`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `list_cloudspace_network_routes`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/routes', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_cloudspace_objectspaces(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_cloudspace_objectspaces  # noqa: E501

        Listing the objectspaces for specific cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_cloudspace_objectspaces(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param bool include_deleted: Include deleted Object spaces
        :param bool only_deleted: Only include deleted Object spaces
        :param str x_fields: An optional fields mask
        :return: ObjectspacesForCloudspace
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_cloudspace_objectspaces_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_cloudspace_objectspaces_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def list_cloudspace_objectspaces_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_cloudspace_objectspaces  # noqa: E501

        Listing the objectspaces for specific cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_cloudspace_objectspaces_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param bool include_deleted: Include deleted Object spaces
        :param bool only_deleted: Only include deleted Object spaces
        :param str x_fields: An optional fields mask
        :return: ObjectspacesForCloudspace
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'include_deleted', 'only_deleted', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_cloudspace_objectspaces" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_cloudspace_objectspaces`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `list_cloudspace_objectspaces`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'include_deleted' in params:
            query_params.append(('include_deleted', params['include_deleted']))  # noqa: E501
        if 'only_deleted' in params:
            query_params.append(('only_deleted', params['only_deleted']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/objectspaces', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ObjectspacesForCloudspace',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_cloudspace_virtual_machines(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_cloudspace_virtual_machines  # noqa: E501

        List VMs on this cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_cloudspace_virtual_machines(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param bool include_deleted: Include deleted machines
        :param bool only_deleted: Only include deleted machines
        :param str x_fields: An optional fields mask
        :return: VirtualMachines
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_cloudspace_virtual_machines_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_cloudspace_virtual_machines_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def list_cloudspace_virtual_machines_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_cloudspace_virtual_machines  # noqa: E501

        List VMs on this cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_cloudspace_virtual_machines_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param bool include_deleted: Include deleted machines
        :param bool only_deleted: Only include deleted machines
        :param str x_fields: An optional fields mask
        :return: VirtualMachines
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'include_deleted', 'only_deleted', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_cloudspace_virtual_machines" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_cloudspace_virtual_machines`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `list_cloudspace_virtual_machines`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'include_deleted' in params:
            query_params.append(('include_deleted', params['include_deleted']))  # noqa: E501
        if 'only_deleted' in params:
            query_params.append(('only_deleted', params['only_deleted']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VirtualMachines',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_cloudspaces(self, customer_id, **kwargs):  # noqa: E501
        """list_cloudspaces  # noqa: E501

        List cloudspaces for the customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_cloudspaces(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param bool include_deleted: Include deleted Cloud spaces
        :param bool only_deleted: Only include deleted Cloud spaces
        :param bool include_disabled: include disabled cloudspaces
        :param list[str] locations: Locations filter
        :param str x_fields: An optional fields mask
        :return: Cloudspaces
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_cloudspaces_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_cloudspaces_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def list_cloudspaces_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """list_cloudspaces  # noqa: E501

        List cloudspaces for the customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_cloudspaces_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param bool include_deleted: Include deleted Cloud spaces
        :param bool only_deleted: Only include deleted Cloud spaces
        :param bool include_disabled: include disabled cloudspaces
        :param list[str] locations: Locations filter
        :param str x_fields: An optional fields mask
        :return: Cloudspaces
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'include_deleted', 'only_deleted', 'include_disabled', 'locations', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_cloudspaces" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_cloudspaces`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []
        if 'include_deleted' in params:
            query_params.append(('include_deleted', params['include_deleted']))  # noqa: E501
        if 'only_deleted' in params:
            query_params.append(('only_deleted', params['only_deleted']))  # noqa: E501
        if 'include_disabled' in params:
            query_params.append(('include_disabled', params['include_disabled']))  # noqa: E501
        if 'locations' in params:
            query_params.append(('locations', params['locations']))  # noqa: E501
            collection_formats['locations'] = 'csv'  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Cloudspaces',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_customer_cdrom_images(self, customer_id, location, **kwargs):  # noqa: E501
        """list_customer_cdrom_images  # noqa: E501

        List public images and customer's CDROM images  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_customer_cdrom_images(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str x_fields: An optional fields mask
        :return: CDROMs
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_customer_cdrom_images_with_http_info(customer_id, location, **kwargs)  # noqa: E501
        else:
            (data) = self.list_customer_cdrom_images_with_http_info(customer_id, location, **kwargs)  # noqa: E501
            return data

    def list_customer_cdrom_images_with_http_info(self, customer_id, location, **kwargs):  # noqa: E501
        """list_customer_cdrom_images  # noqa: E501

        List public images and customer's CDROM images  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_customer_cdrom_images_with_http_info(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str x_fields: An optional fields mask
        :return: CDROMs
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_customer_cdrom_images" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_customer_cdrom_images`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `list_customer_cdrom_images`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/cdrom-images', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CDROMs',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_customer_certificates(self, customer_id, **kwargs):  # noqa: E501
        """list_customer_certificates  # noqa: E501

        List customer certificates  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_customer_certificates(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: CertificatesSimple
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_customer_certificates_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_customer_certificates_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def list_customer_certificates_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """list_customer_certificates  # noqa: E501

        List customer certificates  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_customer_certificates_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: CertificatesSimple
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_customer_certificates" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_customer_certificates`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/certificates/ssl', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CertificatesSimple',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_customer_images(self, customer_id, location, **kwargs):  # noqa: E501
        """list_customer_images  # noqa: E501

        list public images and customer's account images  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_customer_images(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str x_fields: An optional fields mask
        :return: Images
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_customer_images_with_http_info(customer_id, location, **kwargs)  # noqa: E501
        else:
            (data) = self.list_customer_images_with_http_info(customer_id, location, **kwargs)  # noqa: E501
            return data

    def list_customer_images_with_http_info(self, customer_id, location, **kwargs):  # noqa: E501
        """list_customer_images  # noqa: E501

        list public images and customer's account images  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_customer_images_with_http_info(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str x_fields: An optional fields mask
        :return: Images
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_customer_images" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_customer_images`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `list_customer_images`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/vm-images', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Images',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_customer_invoices(self, customer_id, **kwargs):  # noqa: E501
        """list_customer_invoices  # noqa: E501

        List customer Invoices  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_customer_invoices(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerInvoiceList
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_customer_invoices_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_customer_invoices_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def list_customer_invoices_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """list_customer_invoices  # noqa: E501

        List customer Invoices  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_customer_invoices_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerInvoiceList
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_customer_invoices" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_customer_invoices`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/invoices', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomerInvoiceList',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_customer_locations(self, customer_id, **kwargs):  # noqa: E501
        """list_customer_locations  # noqa: E501

        List customer available locations  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_customer_locations(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: VcoPricing
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_customer_locations_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_customer_locations_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def list_customer_locations_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """list_customer_locations  # noqa: E501

        List customer available locations  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_customer_locations_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: VcoPricing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_customer_locations" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_customer_locations`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VcoPricing',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_customers(self, **kwargs):  # noqa: E501
        """list_customers  # noqa: E501

        List customers  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_customers(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_fields: An optional fields mask
        :return: CustomersSimple
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_customers_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.list_customers_with_http_info(**kwargs)  # noqa: E501
            return data

    def list_customers_with_http_info(self, **kwargs):  # noqa: E501
        """list_customers  # noqa: E501

        List customers  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_customers_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_fields: An optional fields mask
        :return: CustomersSimple
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_customers" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomersSimple',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_disk_snapshots(self, customer_id, location, disk_id, **kwargs):  # noqa: E501
        """list_disk_snapshots  # noqa: E501

        List Disk snapshots  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_disk_snapshots(customer_id, location, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param bool include_automatic: Include automatic snapshots
        :param str x_fields: An optional fields mask
        :return: Snapshots
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_disk_snapshots_with_http_info(customer_id, location, disk_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_disk_snapshots_with_http_info(customer_id, location, disk_id, **kwargs)  # noqa: E501
            return data

    def list_disk_snapshots_with_http_info(self, customer_id, location, disk_id, **kwargs):  # noqa: E501
        """list_disk_snapshots  # noqa: E501

        List Disk snapshots  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_disk_snapshots_with_http_info(customer_id, location, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param bool include_automatic: Include automatic snapshots
        :param str x_fields: An optional fields mask
        :return: Snapshots
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'include_automatic', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_disk_snapshots" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_disk_snapshots`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `list_disk_snapshots`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `list_disk_snapshots`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501

        query_params = []
        if 'include_automatic' in params:
            query_params.append(('include_automatic', params['include_automatic']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/snapshots', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Snapshots',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_disks(self, customer_id, location, **kwargs):  # noqa: E501
        """list_disks  # noqa: E501

        List customer disks  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_disks(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param bool include_deleted: Include deleted disks
        :param bool only_deleted: Only include deleted disks
        :param str x_fields: An optional fields mask
        :return: Disks
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_disks_with_http_info(customer_id, location, **kwargs)  # noqa: E501
        else:
            (data) = self.list_disks_with_http_info(customer_id, location, **kwargs)  # noqa: E501
            return data

    def list_disks_with_http_info(self, customer_id, location, **kwargs):  # noqa: E501
        """list_disks  # noqa: E501

        List customer disks  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_disks_with_http_info(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param bool include_deleted: Include deleted disks
        :param bool only_deleted: Only include deleted disks
        :param str x_fields: An optional fields mask
        :return: Disks
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'include_deleted', 'only_deleted', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_disks" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_disks`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `list_disks`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501

        query_params = []
        if 'include_deleted' in params:
            query_params.append(('include_deleted', params['include_deleted']))  # noqa: E501
        if 'only_deleted' in params:
            query_params.append(('only_deleted', params['only_deleted']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Disks',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_disks_virtual_machine(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """list_disks_virtual_machine  # noqa: E501

        List disks on virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_disks_virtual_machine(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: VirtualMachineDisks
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_disks_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_disks_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def list_disks_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """list_disks_virtual_machine  # noqa: E501

        List disks on virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_disks_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: VirtualMachineDisks
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_disks_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_disks_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `list_disks_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `list_disks_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/disks', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VirtualMachineDisks',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_exposed_disks(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_exposed_disks  # noqa: E501

        List exposed disks  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_exposed_disks(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: ExposedDisks
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_exposed_disks_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_exposed_disks_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def list_exposed_disks_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_exposed_disks  # noqa: E501

        List exposed disks  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_exposed_disks_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: ExposedDisks
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_exposed_disks" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_exposed_disks`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `list_exposed_disks`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/exposed-disks', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExposedDisks',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_external_network_interface_models(self, **kwargs):  # noqa: E501
        """list_external_network_interface_models  # noqa: E501

        List supported external network interface models  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_external_network_interface_models(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_fields: An optional fields mask
        :return: ExternalNICModels
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_external_network_interface_models_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.list_external_network_interface_models_with_http_info(**kwargs)  # noqa: E501
            return data

    def list_external_network_interface_models_with_http_info(self, **kwargs):  # noqa: E501
        """list_external_network_interface_models  # noqa: E501

        List supported external network interface models  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_external_network_interface_models_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str x_fields: An optional fields mask
        :return: ExternalNICModels
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_external_network_interface_models" % key
                )
            params[key] = val
        del params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/external-network-interfaces/models', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExternalNICModels',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_external_networks(self, customer_id, location, **kwargs):  # noqa: E501
        """list_external_networks  # noqa: E501

        List of the available external networks in a location  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_external_networks(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str x_fields: An optional fields mask
        :return: ExternalNetworks
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_external_networks_with_http_info(customer_id, location, **kwargs)  # noqa: E501
        else:
            (data) = self.list_external_networks_with_http_info(customer_id, location, **kwargs)  # noqa: E501
            return data

    def list_external_networks_with_http_info(self, customer_id, location, **kwargs):  # noqa: E501
        """list_external_networks  # noqa: E501

        List of the available external networks in a location  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_external_networks_with_http_info(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str x_fields: An optional fields mask
        :return: ExternalNetworks
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_external_networks" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_external_networks`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `list_external_networks`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/external-networks', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExternalNetworks',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_external_networks_virtual_machine(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """list_external_networks_virtual_machine  # noqa: E501

        List external networks (NIC) that the virtual machine is attached to  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_external_networks_virtual_machine(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: ExternalNICS
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_external_networks_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_external_networks_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def list_external_networks_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """list_external_networks_virtual_machine  # noqa: E501

        List external networks (NIC) that the virtual machine is attached to  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_external_networks_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: ExternalNICS
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_external_networks_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_external_networks_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `list_external_networks_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `list_external_networks_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/external-nics', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExternalNICS',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_objectspaces(self, customer_id, **kwargs):  # noqa: E501
        """list_objectspaces  # noqa: E501

        List all object spaces for a customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_objectspaces(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param bool include_deleted: Include deleted Object spaces
        :param bool only_deleted: Only include deleted Object spaces
        :param str x_fields: An optional fields mask
        :return: ObjectSpaces
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_objectspaces_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_objectspaces_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def list_objectspaces_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """list_objectspaces  # noqa: E501

        List all object spaces for a customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_objectspaces_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param bool include_deleted: Include deleted Object spaces
        :param bool only_deleted: Only include deleted Object spaces
        :param str x_fields: An optional fields mask
        :return: ObjectSpaces
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'include_deleted', 'only_deleted', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_objectspaces" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_objectspaces`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []
        if 'include_deleted' in params:
            query_params.append(('include_deleted', params['include_deleted']))  # noqa: E501
        if 'only_deleted' in params:
            query_params.append(('only_deleted', params['only_deleted']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ObjectSpaces',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_portforwards(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_portforwards  # noqa: E501

        Get cloudspace port forwards  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_portforwards(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: Portforwards
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_portforwards_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_portforwards_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def list_portforwards_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_portforwards  # noqa: E501

        Get cloudspace port forwards  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_portforwards_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: Portforwards
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_portforwards" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_portforwards`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `list_portforwards`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/portforwards', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Portforwards',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_remote_cloudspace_connections(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_remote_cloudspace_connections  # noqa: E501

        List remote connections to cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_remote_cloudspace_connections(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: ConnectedCloudspaces
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_remote_cloudspace_connections_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_remote_cloudspace_connections_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def list_remote_cloudspace_connections_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_remote_cloudspace_connections  # noqa: E501

        List remote connections to cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_remote_cloudspace_connections_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: ConnectedCloudspaces
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_remote_cloudspace_connections" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_remote_cloudspace_connections`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `list_remote_cloudspace_connections`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/connected-cloudspaces', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ConnectedCloudspaces',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_role_grants(self, customer_id, role_id, **kwargs):  # noqa: E501
        """list_role_grants  # noqa: E501

        List cloud resources to which the role has access  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_role_grants(customer_id, role_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str role_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRoleResources
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_role_grants_with_http_info(customer_id, role_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_role_grants_with_http_info(customer_id, role_id, **kwargs)  # noqa: E501
            return data

    def list_role_grants_with_http_info(self, customer_id, role_id, **kwargs):  # noqa: E501
        """list_role_grants  # noqa: E501

        List cloud resources to which the role has access  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_role_grants_with_http_info(customer_id, role_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str role_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRoleResources
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'role_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_role_grants" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_role_grants`")  # noqa: E501
        # verify the required parameter 'role_id' is set
        if self.api_client.client_side_validation and ('role_id' not in params or
                                                       params['role_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `role_id` when calling `list_role_grants`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'role_id' in params:
            path_params['role_id'] = params['role_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/roles/{role_id}/grants', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomerRoleResources',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_roles(self, customer_id, **kwargs):  # noqa: E501
        """list_roles  # noqa: E501

        Get customer roles  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_roles(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRoleList
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_roles_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_roles_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def list_roles_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """list_roles  # noqa: E501

        Get customer roles  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_roles_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRoleList
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_roles" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_roles`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/roles', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomerRoleList',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_roles_on_cloudspace(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_roles_on_cloudspace  # noqa: E501

        List roles with access to this cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_roles_on_cloudspace(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRoleList
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_roles_on_cloudspace_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_roles_on_cloudspace_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def list_roles_on_cloudspace_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """list_roles_on_cloudspace  # noqa: E501

        List roles with access to this cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_roles_on_cloudspace_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRoleList
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_roles_on_cloudspace" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_roles_on_cloudspace`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `list_roles_on_cloudspace`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/granted-roles', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomerRoleList',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_roles_on_customer(self, customer_id, **kwargs):  # noqa: E501
        """list_roles_on_customer  # noqa: E501

        List roles with customer wide access  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_roles_on_customer(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRoleList
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_roles_on_customer_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_roles_on_customer_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def list_roles_on_customer_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """list_roles_on_customer  # noqa: E501

        List roles with customer wide access  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_roles_on_customer_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRoleList
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_roles_on_customer" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_roles_on_customer`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/granted-roles', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomerRoleList',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_roles_on_location(self, customer_id, location, **kwargs):  # noqa: E501
        """list_roles_on_location  # noqa: E501

        List roles with access to this location  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_roles_on_location(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRoleList
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_roles_on_location_with_http_info(customer_id, location, **kwargs)  # noqa: E501
        else:
            (data) = self.list_roles_on_location_with_http_info(customer_id, location, **kwargs)  # noqa: E501
            return data

    def list_roles_on_location_with_http_info(self, customer_id, location, **kwargs):  # noqa: E501
        """list_roles_on_location  # noqa: E501

        List roles with access to this location  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_roles_on_location_with_http_info(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRoleList
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_roles_on_location" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_roles_on_location`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `list_roles_on_location`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/granted-roles', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomerRoleList',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_roles_on_virtual_machine(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """list_roles_on_virtual_machine  # noqa: E501

        List roles with access to a virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_roles_on_virtual_machine(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRoleList
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_roles_on_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_roles_on_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def list_roles_on_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """list_roles_on_virtual_machine  # noqa: E501

        List roles with access to a virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_roles_on_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: CustomerRoleList
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_roles_on_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_roles_on_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `list_roles_on_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `list_roles_on_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/granted-roles', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CustomerRoleList',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_virtual_machine_cdro_ms(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """list_virtual_machine_cdro_ms  # noqa: E501

        List CDROM images attached to virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_virtual_machine_cdro_ms(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: VirtualMachineDisks
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_virtual_machine_cdro_ms_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_virtual_machine_cdro_ms_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def list_virtual_machine_cdro_ms_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """list_virtual_machine_cdro_ms  # noqa: E501

        List CDROM images attached to virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_virtual_machine_cdro_ms_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: VirtualMachineDisks
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_virtual_machine_cdro_ms" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `list_virtual_machine_cdro_ms`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `list_virtual_machine_cdro_ms`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `list_virtual_machine_cdro_ms`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/cdrom-images', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VirtualMachineDisks',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def move_virtual_machine(self, customer_id, cloudspace_id, vm_id, target_cloudspace_id, **kwargs):  # noqa: E501
        """move_virtual_machine  # noqa: E501

        Move virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.move_virtual_machine(customer_id, cloudspace_id, vm_id, target_cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str target_cloudspace_id: ID of target Cloudspace (required)
        :param str target_ip_address: IP Address for the VM at the target Cloudspace Should be a valid and available IP address in target Cloudspace network
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.move_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, target_cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.move_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, target_cloudspace_id, **kwargs)  # noqa: E501
            return data

    def move_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, target_cloudspace_id, **kwargs):  # noqa: E501
        """move_virtual_machine  # noqa: E501

        Move virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.move_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, target_cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str target_cloudspace_id: ID of target Cloudspace (required)
        :param str target_ip_address: IP Address for the VM at the target Cloudspace Should be a valid and available IP address in target Cloudspace network
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'target_cloudspace_id', 'target_ip_address', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method move_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `move_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `move_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `move_virtual_machine`")  # noqa: E501
        # verify the required parameter 'target_cloudspace_id' is set
        if self.api_client.client_side_validation and ('target_cloudspace_id' not in params or
                                                       params['target_cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `target_cloudspace_id` when calling `move_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'target_ip_address' in params:
            query_params.append(('target_ip_address', params['target_ip_address']))  # noqa: E501
        if 'target_cloudspace_id' in params:
            query_params.append(('target_cloudspace_id', params['target_cloudspace_id']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/move', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def pause_virtual_machine(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """pause_virtual_machine  # noqa: E501

        Pause virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.pause_virtual_machine(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.pause_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.pause_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def pause_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """pause_virtual_machine  # noqa: E501

        Pause virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.pause_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method pause_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `pause_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `pause_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `pause_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/pause', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def read_file(self, customer_id, cloudspace_id, vm_id, size, filepath, **kwargs):  # noqa: E501
        """read_file  # noqa: E501

        Read file from virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.read_file(customer_id, cloudspace_id, vm_id, size, filepath, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int size: Size of data to read maximuxm 2MiB (required)
        :param str filepath: filepath to read from (required)
        :param int seek: Offset in the file to read from
        :param str x_fields: An optional fields mask
        :return: VmReadFileModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.read_file_with_http_info(customer_id, cloudspace_id, vm_id, size, filepath, **kwargs)  # noqa: E501
        else:
            (data) = self.read_file_with_http_info(customer_id, cloudspace_id, vm_id, size, filepath, **kwargs)  # noqa: E501
            return data

    def read_file_with_http_info(self, customer_id, cloudspace_id, vm_id, size, filepath, **kwargs):  # noqa: E501
        """read_file  # noqa: E501

        Read file from virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.read_file_with_http_info(customer_id, cloudspace_id, vm_id, size, filepath, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int size: Size of data to read maximuxm 2MiB (required)
        :param str filepath: filepath to read from (required)
        :param int seek: Offset in the file to read from
        :param str x_fields: An optional fields mask
        :return: VmReadFileModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'size', 'filepath', 'seek', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method read_file" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `read_file`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `read_file`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `read_file`")  # noqa: E501
        # verify the required parameter 'size' is set
        if self.api_client.client_side_validation and ('size' not in params or
                                                       params['size'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `size` when calling `read_file`")  # noqa: E501
        # verify the required parameter 'filepath' is set
        if self.api_client.client_side_validation and ('filepath' not in params or
                                                       params['filepath'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `filepath` when calling `read_file`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'size' in params:
            query_params.append(('size', params['size']))  # noqa: E501
        if 'seek' in params:
            query_params.append(('seek', params['seek']))  # noqa: E501
        if 'filepath' in params:
            query_params.append(('filepath', params['filepath']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/file', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VmReadFileModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def reboot_virtual_machine(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """reboot_virtual_machine  # noqa: E501

        Reboot virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reboot_virtual_machine(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.reboot_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.reboot_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def reboot_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """reboot_virtual_machine  # noqa: E501

        Reboot virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reboot_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reboot_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `reboot_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `reboot_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `reboot_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/reboot', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def recycle_bin(self, customer_id, **kwargs):  # noqa: E501
        """recycle_bin  # noqa: E501

        list all deleted resources for the customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.recycle_bin(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: RecycleBin
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.recycle_bin_with_http_info(customer_id, **kwargs)  # noqa: E501
        else:
            (data) = self.recycle_bin_with_http_info(customer_id, **kwargs)  # noqa: E501
            return data

    def recycle_bin_with_http_info(self, customer_id, **kwargs):  # noqa: E501
        """recycle_bin  # noqa: E501

        list all deleted resources for the customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.recycle_bin_with_http_info(customer_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str x_fields: An optional fields mask
        :return: RecycleBin
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method recycle_bin" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `recycle_bin`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/recycle-bin', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='RecycleBin',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def remove_cloudspace_external_network(self, customer_id, cloudspace_id, external_network_ip, external_network_id, **kwargs):  # noqa: E501
        """remove_cloudspace_external_network  # noqa: E501

        Remove cloudspace external network  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_cloudspace_external_network(customer_id, cloudspace_id, external_network_ip, external_network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str external_network_ip: optional ip address inside the external network (required)
        :param int external_network_id: optional id to take ip address from.If omited will search for available network (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.remove_cloudspace_external_network_with_http_info(customer_id, cloudspace_id, external_network_ip, external_network_id, **kwargs)  # noqa: E501
        else:
            (data) = self.remove_cloudspace_external_network_with_http_info(customer_id, cloudspace_id, external_network_ip, external_network_id, **kwargs)  # noqa: E501
            return data

    def remove_cloudspace_external_network_with_http_info(self, customer_id, cloudspace_id, external_network_ip, external_network_id, **kwargs):  # noqa: E501
        """remove_cloudspace_external_network  # noqa: E501

        Remove cloudspace external network  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_cloudspace_external_network_with_http_info(customer_id, cloudspace_id, external_network_ip, external_network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str external_network_ip: optional ip address inside the external network (required)
        :param int external_network_id: optional id to take ip address from.If omited will search for available network (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'external_network_ip', 'external_network_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method remove_cloudspace_external_network" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `remove_cloudspace_external_network`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `remove_cloudspace_external_network`")  # noqa: E501
        # verify the required parameter 'external_network_ip' is set
        if self.api_client.client_side_validation and ('external_network_ip' not in params or
                                                       params['external_network_ip'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `external_network_ip` when calling `remove_cloudspace_external_network`")  # noqa: E501
        # verify the required parameter 'external_network_id' is set
        if self.api_client.client_side_validation and ('external_network_id' not in params or
                                                       params['external_network_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `external_network_id` when calling `remove_cloudspace_external_network`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'external_network_ip' in params:
            query_params.append(('external_network_ip', params['external_network_ip']))  # noqa: E501
        if 'external_network_id' in params:
            query_params.append(('external_network_id', params['external_network_id']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/external-network', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def remove_cloudspace_network_route(self, customer_id, cloudspace_id, destination, gateway, **kwargs):  # noqa: E501
        """remove_cloudspace_network_route  # noqa: E501

        Remove extra route from network  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_cloudspace_network_route(customer_id, cloudspace_id, destination, gateway, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str destination: Destination network to route (required)
        :param str gateway: Gateway to route desination over (required)
        :param int table: routing table to add route to
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.remove_cloudspace_network_route_with_http_info(customer_id, cloudspace_id, destination, gateway, **kwargs)  # noqa: E501
        else:
            (data) = self.remove_cloudspace_network_route_with_http_info(customer_id, cloudspace_id, destination, gateway, **kwargs)  # noqa: E501
            return data

    def remove_cloudspace_network_route_with_http_info(self, customer_id, cloudspace_id, destination, gateway, **kwargs):  # noqa: E501
        """remove_cloudspace_network_route  # noqa: E501

        Remove extra route from network  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_cloudspace_network_route_with_http_info(customer_id, cloudspace_id, destination, gateway, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str destination: Destination network to route (required)
        :param str gateway: Gateway to route desination over (required)
        :param int table: routing table to add route to
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'destination', 'gateway', 'table', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method remove_cloudspace_network_route" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `remove_cloudspace_network_route`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `remove_cloudspace_network_route`")  # noqa: E501
        # verify the required parameter 'destination' is set
        if self.api_client.client_side_validation and ('destination' not in params or
                                                       params['destination'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `destination` when calling `remove_cloudspace_network_route`")  # noqa: E501
        # verify the required parameter 'gateway' is set
        if self.api_client.client_side_validation and ('gateway' not in params or
                                                       params['gateway'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `gateway` when calling `remove_cloudspace_network_route`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'table' in params:
            query_params.append(('table', params['table']))  # noqa: E501
        if 'destination' in params:
            query_params.append(('destination', params['destination']))  # noqa: E501
        if 'gateway' in params:
            query_params.append(('gateway', params['gateway']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/routes', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def remove_customer_location(self, customer_id, location, **kwargs):  # noqa: E501
        """remove_customer_location  # noqa: E501

        remove location from Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_customer_location(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.remove_customer_location_with_http_info(customer_id, location, **kwargs)  # noqa: E501
        else:
            (data) = self.remove_customer_location_with_http_info(customer_id, location, **kwargs)  # noqa: E501
            return data

    def remove_customer_location_with_http_info(self, customer_id, location, **kwargs):  # noqa: E501
        """remove_customer_location  # noqa: E501

        remove location from Customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_customer_location_with_http_info(customer_id, location, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method remove_customer_location" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `remove_customer_location`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `remove_customer_location`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def rename_cloudspace(self, customer_id, cloudspace_id, name, **kwargs):  # noqa: E501
        """rename_cloudspace  # noqa: E501

        Rename cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.rename_cloudspace(customer_id, cloudspace_id, name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str name: Cloudspace Name (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.rename_cloudspace_with_http_info(customer_id, cloudspace_id, name, **kwargs)  # noqa: E501
        else:
            (data) = self.rename_cloudspace_with_http_info(customer_id, cloudspace_id, name, **kwargs)  # noqa: E501
            return data

    def rename_cloudspace_with_http_info(self, customer_id, cloudspace_id, name, **kwargs):  # noqa: E501
        """rename_cloudspace  # noqa: E501

        Rename cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.rename_cloudspace_with_http_info(customer_id, cloudspace_id, name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str name: Cloudspace Name (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'name', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method rename_cloudspace" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `rename_cloudspace`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `rename_cloudspace`")  # noqa: E501
        # verify the required parameter 'name' is set
        if self.api_client.client_side_validation and ('name' not in params or
                                                       params['name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `name` when calling `rename_cloudspace`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'name' in params:
            query_params.append(('name', params['name']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/name', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def rename_virtual_machine(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """rename_virtual_machine  # noqa: E501

        Update virtual machine name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.rename_virtual_machine(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str name: Virtual Machine name
        :param str x_fields: An optional fields mask
        :return: VmIdModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.rename_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.rename_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def rename_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """rename_virtual_machine  # noqa: E501

        Update virtual machine name  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.rename_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str name: Virtual Machine name
        :param str x_fields: An optional fields mask
        :return: VmIdModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'name', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method rename_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `rename_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `rename_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `rename_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'name' in params:
            query_params.append(('name', params['name']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/name', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VmIdModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def reset_bucket_limit(self, customer_id, objectspace_id, bucket_id, **kwargs):  # noqa: E501
        """reset_bucket_limit  # noqa: E501

        Reset a bucket limit to default  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reset_bucket_limit(customer_id, objectspace_id, bucket_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str bucket_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.reset_bucket_limit_with_http_info(customer_id, objectspace_id, bucket_id, **kwargs)  # noqa: E501
        else:
            (data) = self.reset_bucket_limit_with_http_info(customer_id, objectspace_id, bucket_id, **kwargs)  # noqa: E501
            return data

    def reset_bucket_limit_with_http_info(self, customer_id, objectspace_id, bucket_id, **kwargs):  # noqa: E501
        """reset_bucket_limit  # noqa: E501

        Reset a bucket limit to default  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reset_bucket_limit_with_http_info(customer_id, objectspace_id, bucket_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str bucket_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'objectspace_id', 'bucket_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reset_bucket_limit" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `reset_bucket_limit`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `reset_bucket_limit`")  # noqa: E501
        # verify the required parameter 'bucket_id' is set
        if self.api_client.client_side_validation and ('bucket_id' not in params or
                                                       params['bucket_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `bucket_id` when calling `reset_bucket_limit`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'objectspace_id' in params:
            path_params['objectspace_id'] = params['objectspace_id']  # noqa: E501
        if 'bucket_id' in params:
            path_params['bucket_id'] = params['bucket_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces/{objectspace_id}/{bucket_id}/reset-limit', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def reset_objectspace(self, customer_id, objectspace_id, **kwargs):  # noqa: E501
        """reset_objectspace  # noqa: E501

        Resetting objectspace secret and access key  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reset_objectspace(customer_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: ResetObjectspaceModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.reset_objectspace_with_http_info(customer_id, objectspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.reset_objectspace_with_http_info(customer_id, objectspace_id, **kwargs)  # noqa: E501
            return data

    def reset_objectspace_with_http_info(self, customer_id, objectspace_id, **kwargs):  # noqa: E501
        """reset_objectspace  # noqa: E501

        Resetting objectspace secret and access key  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reset_objectspace_with_http_info(customer_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: ResetObjectspaceModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'objectspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reset_objectspace" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `reset_objectspace`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `reset_objectspace`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'objectspace_id' in params:
            path_params['objectspace_id'] = params['objectspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces/{objectspace_id}/reset', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ResetObjectspaceModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def reset_virtual_machine(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """reset_virtual_machine  # noqa: E501

        Reset virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reset_virtual_machine(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.reset_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.reset_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def reset_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """reset_virtual_machine  # noqa: E501

        Reset virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reset_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reset_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `reset_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `reset_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `reset_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/reset', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def resize_disk(self, customer_id, location, disk_id, disk_size, **kwargs):  # noqa: E501
        """resize_disk  # noqa: E501

        Update disk size  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.resize_disk(customer_id, location, disk_id, disk_size, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param int disk_size: Disk Size in GiB (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.resize_disk_with_http_info(customer_id, location, disk_id, disk_size, **kwargs)  # noqa: E501
        else:
            (data) = self.resize_disk_with_http_info(customer_id, location, disk_id, disk_size, **kwargs)  # noqa: E501
            return data

    def resize_disk_with_http_info(self, customer_id, location, disk_id, disk_size, **kwargs):  # noqa: E501
        """resize_disk  # noqa: E501

        Update disk size  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.resize_disk_with_http_info(customer_id, location, disk_id, disk_size, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param int disk_size: Disk Size in GiB (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'disk_size', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method resize_disk" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `resize_disk`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `resize_disk`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `resize_disk`")  # noqa: E501
        # verify the required parameter 'disk_size' is set
        if self.api_client.client_side_validation and ('disk_size' not in params or
                                                       params['disk_size'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_size` when calling `resize_disk`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501

        query_params = []
        if 'disk_size' in params:
            query_params.append(('disk_size', params['disk_size']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/size', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def resize_virtual_machine(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """resize_virtual_machine  # noqa: E501

        Update virtual machine sizes of CPUs or memory  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.resize_virtual_machine(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int vcpus: Number of cpu to assign to machine
        :param int memory: Amount of memory to assign to machine in MiB
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.resize_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.resize_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def resize_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """resize_virtual_machine  # noqa: E501

        Update virtual machine sizes of CPUs or memory  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.resize_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int vcpus: Number of cpu to assign to machine
        :param int memory: Amount of memory to assign to machine in MiB
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'vcpus', 'memory', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method resize_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `resize_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `resize_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `resize_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'vcpus' in params:
            query_params.append(('vcpus', params['vcpus']))  # noqa: E501
        if 'memory' in params:
            query_params.append(('memory', params['memory']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/size', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def restore_bucket(self, customer_id, objectspace_id, bucket_id, **kwargs):  # noqa: E501
        """restore_bucket  # noqa: E501

        Restore a soft-deleted bucket  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_bucket(customer_id, objectspace_id, bucket_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str bucket_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.restore_bucket_with_http_info(customer_id, objectspace_id, bucket_id, **kwargs)  # noqa: E501
        else:
            (data) = self.restore_bucket_with_http_info(customer_id, objectspace_id, bucket_id, **kwargs)  # noqa: E501
            return data

    def restore_bucket_with_http_info(self, customer_id, objectspace_id, bucket_id, **kwargs):  # noqa: E501
        """restore_bucket  # noqa: E501

        Restore a soft-deleted bucket  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_bucket_with_http_info(customer_id, objectspace_id, bucket_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str bucket_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'objectspace_id', 'bucket_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method restore_bucket" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `restore_bucket`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `restore_bucket`")  # noqa: E501
        # verify the required parameter 'bucket_id' is set
        if self.api_client.client_side_validation and ('bucket_id' not in params or
                                                       params['bucket_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `bucket_id` when calling `restore_bucket`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'objectspace_id' in params:
            path_params['objectspace_id'] = params['objectspace_id']  # noqa: E501
        if 'bucket_id' in params:
            path_params['bucket_id'] = params['bucket_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces/{objectspace_id}/{bucket_id}/restore', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def restore_cloudspace(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """restore_cloudspace  # noqa: E501

        Restore cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_cloudspace(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str reason: Reason for restoring
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.restore_cloudspace_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.restore_cloudspace_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def restore_cloudspace_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """restore_cloudspace  # noqa: E501

        Restore cloudspace  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_cloudspace_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str reason: Reason for restoring
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'reason', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method restore_cloudspace" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `restore_cloudspace`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `restore_cloudspace`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'reason' in params:
            query_params.append(('reason', params['reason']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/restore', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def restore_customer_cdrom_image(self, customer_id, location, cdrom_id, **kwargs):  # noqa: E501
        """restore_customer_cdrom_image  # noqa: E501

        Restore customer CDROM Image  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_customer_cdrom_image(customer_id, location, cdrom_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int cdrom_id: (required)
        :param str reason: Reason for enabling
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.restore_customer_cdrom_image_with_http_info(customer_id, location, cdrom_id, **kwargs)  # noqa: E501
        else:
            (data) = self.restore_customer_cdrom_image_with_http_info(customer_id, location, cdrom_id, **kwargs)  # noqa: E501
            return data

    def restore_customer_cdrom_image_with_http_info(self, customer_id, location, cdrom_id, **kwargs):  # noqa: E501
        """restore_customer_cdrom_image  # noqa: E501

        Restore customer CDROM Image  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_customer_cdrom_image_with_http_info(customer_id, location, cdrom_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int cdrom_id: (required)
        :param str reason: Reason for enabling
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'cdrom_id', 'reason', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method restore_customer_cdrom_image" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `restore_customer_cdrom_image`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `restore_customer_cdrom_image`")  # noqa: E501
        # verify the required parameter 'cdrom_id' is set
        if self.api_client.client_side_validation and ('cdrom_id' not in params or
                                                       params['cdrom_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cdrom_id` when calling `restore_customer_cdrom_image`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'cdrom_id' in params:
            path_params['cdrom_id'] = params['cdrom_id']  # noqa: E501

        query_params = []
        if 'reason' in params:
            query_params.append(('reason', params['reason']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/cdrom-images/{cdrom_id}/restore', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def restore_customer_image(self, customer_id, location, image_id, **kwargs):  # noqa: E501
        """restore_customer_image  # noqa: E501

        Restore customer Image  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_customer_image(customer_id, location, image_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int image_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.restore_customer_image_with_http_info(customer_id, location, image_id, **kwargs)  # noqa: E501
        else:
            (data) = self.restore_customer_image_with_http_info(customer_id, location, image_id, **kwargs)  # noqa: E501
            return data

    def restore_customer_image_with_http_info(self, customer_id, location, image_id, **kwargs):  # noqa: E501
        """restore_customer_image  # noqa: E501

        Restore customer Image  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_customer_image_with_http_info(customer_id, location, image_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int image_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'image_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method restore_customer_image" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `restore_customer_image`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `restore_customer_image`")  # noqa: E501
        # verify the required parameter 'image_id' is set
        if self.api_client.client_side_validation and ('image_id' not in params or
                                                       params['image_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `image_id` when calling `restore_customer_image`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'image_id' in params:
            path_params['image_id'] = params['image_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/vm-images/{image_id}/restore', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def restore_disk(self, customer_id, location, disk_id, **kwargs):  # noqa: E501
        """restore_disk  # noqa: E501

        Restore disk  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_disk(customer_id, location, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str reason: Reason for enabling
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.restore_disk_with_http_info(customer_id, location, disk_id, **kwargs)  # noqa: E501
        else:
            (data) = self.restore_disk_with_http_info(customer_id, location, disk_id, **kwargs)  # noqa: E501
            return data

    def restore_disk_with_http_info(self, customer_id, location, disk_id, **kwargs):  # noqa: E501
        """restore_disk  # noqa: E501

        Restore disk  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_disk_with_http_info(customer_id, location, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str reason: Reason for enabling
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'reason', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method restore_disk" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `restore_disk`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `restore_disk`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `restore_disk`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501

        query_params = []
        if 'reason' in params:
            query_params.append(('reason', params['reason']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/restore', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def restore_objectspace(self, customer_id, objectspace_id, **kwargs):  # noqa: E501
        """restore_objectspace  # noqa: E501

        Restoring deleted and destroyed objectspaces  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_objectspace(customer_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.restore_objectspace_with_http_info(customer_id, objectspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.restore_objectspace_with_http_info(customer_id, objectspace_id, **kwargs)  # noqa: E501
            return data

    def restore_objectspace_with_http_info(self, customer_id, objectspace_id, **kwargs):  # noqa: E501
        """restore_objectspace  # noqa: E501

        Restoring deleted and destroyed objectspaces  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_objectspace_with_http_info(customer_id, objectspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'objectspace_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method restore_objectspace" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `restore_objectspace`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `restore_objectspace`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'objectspace_id' in params:
            path_params['objectspace_id'] = params['objectspace_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces/{objectspace_id}/restore', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def restore_virtual_machine(self, customer_id, cloudspace_id, vm_id, reason, **kwargs):  # noqa: E501
        """restore_virtual_machine  # noqa: E501

        Restore virtual machine from recycle bin  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_virtual_machine(customer_id, cloudspace_id, vm_id, reason, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str reason: Reason for restoring (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.restore_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, reason, **kwargs)  # noqa: E501
        else:
            (data) = self.restore_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, reason, **kwargs)  # noqa: E501
            return data

    def restore_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, reason, **kwargs):  # noqa: E501
        """restore_virtual_machine  # noqa: E501

        Restore virtual machine from recycle bin  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, reason, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str reason: Reason for restoring (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'reason', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method restore_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `restore_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `restore_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `restore_virtual_machine`")  # noqa: E501
        # verify the required parameter 'reason' is set
        if self.api_client.client_side_validation and ('reason' not in params or
                                                       params['reason'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `reason` when calling `restore_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'reason' in params:
            query_params.append(('reason', params['reason']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/restore', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def resume_virtual_machine(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """resume_virtual_machine  # noqa: E501

        Resume virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.resume_virtual_machine(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.resume_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.resume_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def resume_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """resume_virtual_machine  # noqa: E501

        Resume virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.resume_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method resume_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `resume_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `resume_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `resume_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/resume', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def rollback_disk_snapshot(self, customer_id, location, disk_id, snapshot_id, **kwargs):  # noqa: E501
        """rollback_disk_snapshot  # noqa: E501

        Rollback Disk snapshot  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.rollback_disk_snapshot(customer_id, location, disk_id, snapshot_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str snapshot_id: (required)
        :param bool all_vm_disks: Rollback of all snapshots that were created in the same action
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.rollback_disk_snapshot_with_http_info(customer_id, location, disk_id, snapshot_id, **kwargs)  # noqa: E501
        else:
            (data) = self.rollback_disk_snapshot_with_http_info(customer_id, location, disk_id, snapshot_id, **kwargs)  # noqa: E501
            return data

    def rollback_disk_snapshot_with_http_info(self, customer_id, location, disk_id, snapshot_id, **kwargs):  # noqa: E501
        """rollback_disk_snapshot  # noqa: E501

        Rollback Disk snapshot  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.rollback_disk_snapshot_with_http_info(customer_id, location, disk_id, snapshot_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str snapshot_id: (required)
        :param bool all_vm_disks: Rollback of all snapshots that were created in the same action
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'snapshot_id', 'all_vm_disks']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method rollback_disk_snapshot" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `rollback_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `rollback_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `rollback_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'snapshot_id' is set
        if self.api_client.client_side_validation and ('snapshot_id' not in params or
                                                       params['snapshot_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `snapshot_id` when calling `rollback_disk_snapshot`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501
        if 'snapshot_id' in params:
            path_params['snapshot_id'] = params['snapshot_id']  # noqa: E501

        query_params = []
        if 'all_vm_disks' in params:
            query_params.append(('all_vm_disks', params['all_vm_disks']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/snapshots/{snapshot_id}/rollback', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def self_create_customer(self, payload, **kwargs):  # noqa: E501
        """self_create_customer  # noqa: E501

        Self-create a new customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.self_create_customer(payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CustomerSelfCreate payload: (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.self_create_customer_with_http_info(payload, **kwargs)  # noqa: E501
        else:
            (data) = self.self_create_customer_with_http_info(payload, **kwargs)  # noqa: E501
            return data

    def self_create_customer_with_http_info(self, payload, **kwargs):  # noqa: E501
        """self_create_customer  # noqa: E501

        Self-create a new customer  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.self_create_customer_with_http_info(payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CustomerSelfCreate payload: (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['payload']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method self_create_customer" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `self_create_customer`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/self-creation', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def set_bucket_limit(self, customer_id, objectspace_id, bucket_id, limit, **kwargs):  # noqa: E501
        """set_bucket_limit  # noqa: E501

        Set a bucket limit  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_bucket_limit(customer_id, objectspace_id, bucket_id, limit, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str bucket_id: (required)
        :param int limit: the number of iops for the bucket (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_bucket_limit_with_http_info(customer_id, objectspace_id, bucket_id, limit, **kwargs)  # noqa: E501
        else:
            (data) = self.set_bucket_limit_with_http_info(customer_id, objectspace_id, bucket_id, limit, **kwargs)  # noqa: E501
            return data

    def set_bucket_limit_with_http_info(self, customer_id, objectspace_id, bucket_id, limit, **kwargs):  # noqa: E501
        """set_bucket_limit  # noqa: E501

        Set a bucket limit  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_bucket_limit_with_http_info(customer_id, objectspace_id, bucket_id, limit, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str bucket_id: (required)
        :param int limit: the number of iops for the bucket (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'objectspace_id', 'bucket_id', 'limit', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_bucket_limit" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `set_bucket_limit`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `set_bucket_limit`")  # noqa: E501
        # verify the required parameter 'bucket_id' is set
        if self.api_client.client_side_validation and ('bucket_id' not in params or
                                                       params['bucket_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `bucket_id` when calling `set_bucket_limit`")  # noqa: E501
        # verify the required parameter 'limit' is set
        if self.api_client.client_side_validation and ('limit' not in params or
                                                       params['limit'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `limit` when calling `set_bucket_limit`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'objectspace_id' in params:
            path_params['objectspace_id'] = params['objectspace_id']  # noqa: E501
        if 'bucket_id' in params:
            path_params['bucket_id'] = params['bucket_id']  # noqa: E501

        query_params = []
        if 'limit' in params:
            query_params.append(('limit', params['limit']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces/{objectspace_id}/{bucket_id}/bucket-limit', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def set_cloudspace_default_gateway(self, customer_id, cloudspace_id, gateway, **kwargs):  # noqa: E501
        """set_cloudspace_default_gateway  # noqa: E501

        Set cloudspace default gateway  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_cloudspace_default_gateway(customer_id, cloudspace_id, gateway, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str gateway: Default Gateway to set (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_cloudspace_default_gateway_with_http_info(customer_id, cloudspace_id, gateway, **kwargs)  # noqa: E501
        else:
            (data) = self.set_cloudspace_default_gateway_with_http_info(customer_id, cloudspace_id, gateway, **kwargs)  # noqa: E501
            return data

    def set_cloudspace_default_gateway_with_http_info(self, customer_id, cloudspace_id, gateway, **kwargs):  # noqa: E501
        """set_cloudspace_default_gateway  # noqa: E501

        Set cloudspace default gateway  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_cloudspace_default_gateway_with_http_info(customer_id, cloudspace_id, gateway, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str gateway: Default Gateway to set (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'gateway']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_cloudspace_default_gateway" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `set_cloudspace_default_gateway`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `set_cloudspace_default_gateway`")  # noqa: E501
        # verify the required parameter 'gateway' is set
        if self.api_client.client_side_validation and ('gateway' not in params or
                                                       params['gateway'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `gateway` when calling `set_cloudspace_default_gateway`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'gateway' in params:
            query_params.append(('gateway', params['gateway']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/default-gateway', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def set_cloudspace_proxy_config(self, customer_id, cloudspace_id, payload, **kwargs):  # noqa: E501
        """set_cloudspace_proxy_config  # noqa: E501

        Set cloudspace proxy config  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_cloudspace_proxy_config(customer_id, cloudspace_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param AddProxyInput payload: (required)
        :param str proxy_type: Proxy Type, currently should be traefik:2.3
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_cloudspace_proxy_config_with_http_info(customer_id, cloudspace_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.set_cloudspace_proxy_config_with_http_info(customer_id, cloudspace_id, payload, **kwargs)  # noqa: E501
            return data

    def set_cloudspace_proxy_config_with_http_info(self, customer_id, cloudspace_id, payload, **kwargs):  # noqa: E501
        """set_cloudspace_proxy_config  # noqa: E501

        Set cloudspace proxy config  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_cloudspace_proxy_config_with_http_info(customer_id, cloudspace_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param AddProxyInput payload: (required)
        :param str proxy_type: Proxy Type, currently should be traefik:2.3
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'payload', 'proxy_type']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_cloudspace_proxy_config" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `set_cloudspace_proxy_config`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `set_cloudspace_proxy_config`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `set_cloudspace_proxy_config`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'proxy_type' in params:
            query_params.append(('proxy_type', params['proxy_type']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/proxy-server', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def set_disk_limit_io(self, customer_id, location, disk_id, **kwargs):  # noqa: E501
        """set_disk_limit_io  # noqa: E501

        Set disk IO Tune  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_disk_limit_io(customer_id, location, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param int iops: Total iops per sec. Minimum 100
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_disk_limit_io_with_http_info(customer_id, location, disk_id, **kwargs)  # noqa: E501
        else:
            (data) = self.set_disk_limit_io_with_http_info(customer_id, location, disk_id, **kwargs)  # noqa: E501
            return data

    def set_disk_limit_io_with_http_info(self, customer_id, location, disk_id, **kwargs):  # noqa: E501
        """set_disk_limit_io  # noqa: E501

        Set disk IO Tune  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_disk_limit_io_with_http_info(customer_id, location, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param int iops: Total iops per sec. Minimum 100
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'iops', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_disk_limit_io" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `set_disk_limit_io`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `set_disk_limit_io`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `set_disk_limit_io`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501

        query_params = []
        if 'iops' in params:
            query_params.append(('iops', params['iops']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/limitio', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def start_virtual_machine(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """start_virtual_machine  # noqa: E501

        Start virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.start_virtual_machine(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int rescue_disk_id: Rescue Disk ID
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.start_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.start_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def start_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """start_virtual_machine  # noqa: E501

        Start virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.start_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param int rescue_disk_id: Rescue Disk ID
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'rescue_disk_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method start_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `start_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `start_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `start_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'rescue_disk_id' in params:
            query_params.append(('rescue_disk_id', params['rescue_disk_id']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/start', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def stop_virtual_machine(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """stop_virtual_machine  # noqa: E501

        Stop virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.stop_virtual_machine(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param bool force: Force stop VM
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.stop_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.stop_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def stop_virtual_machine_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """stop_virtual_machine  # noqa: E501

        Stop virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.stop_virtual_machine_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param bool force: Force stop VM
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'force', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method stop_virtual_machine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `stop_virtual_machine`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `stop_virtual_machine`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `stop_virtual_machine`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'force' in params:
            query_params.append(('force', params['force']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/stop', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def take_disk_snapshot(self, customer_id, location, disk_id, snapshot_name, **kwargs):  # noqa: E501
        """take_disk_snapshot  # noqa: E501

        Take Disk snapshot  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.take_disk_snapshot(customer_id, location, disk_id, snapshot_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str snapshot_name: Snapshot Name (required)
        :param bool all_vm_disks: Take Snapshots of All VM disks
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.take_disk_snapshot_with_http_info(customer_id, location, disk_id, snapshot_name, **kwargs)  # noqa: E501
        else:
            (data) = self.take_disk_snapshot_with_http_info(customer_id, location, disk_id, snapshot_name, **kwargs)  # noqa: E501
            return data

    def take_disk_snapshot_with_http_info(self, customer_id, location, disk_id, snapshot_name, **kwargs):  # noqa: E501
        """take_disk_snapshot  # noqa: E501

        Take Disk snapshot  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.take_disk_snapshot_with_http_info(customer_id, location, disk_id, snapshot_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str snapshot_name: Snapshot Name (required)
        :param bool all_vm_disks: Take Snapshots of All VM disks
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'snapshot_name', 'all_vm_disks']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method take_disk_snapshot" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `take_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `take_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `take_disk_snapshot`")  # noqa: E501
        # verify the required parameter 'snapshot_name' is set
        if self.api_client.client_side_validation and ('snapshot_name' not in params or
                                                       params['snapshot_name'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `snapshot_name` when calling `take_disk_snapshot`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501

        query_params = []
        if 'snapshot_name' in params:
            query_params.append(('snapshot_name', params['snapshot_name']))  # noqa: E501
        if 'all_vm_disks' in params:
            query_params.append(('all_vm_disks', params['all_vm_disks']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/snapshots', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def unexpose_disk(self, customer_id, cloudspace_id, disk_id, **kwargs):  # noqa: E501
        """unexpose_disk  # noqa: E501

        Unexpose an exposed disk  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unexpose_disk(customer_id, cloudspace_id, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int disk_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.unexpose_disk_with_http_info(customer_id, cloudspace_id, disk_id, **kwargs)  # noqa: E501
        else:
            (data) = self.unexpose_disk_with_http_info(customer_id, cloudspace_id, disk_id, **kwargs)  # noqa: E501
            return data

    def unexpose_disk_with_http_info(self, customer_id, cloudspace_id, disk_id, **kwargs):  # noqa: E501
        """unexpose_disk  # noqa: E501

        Unexpose an exposed disk  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unexpose_disk_with_http_info(customer_id, cloudspace_id, disk_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int disk_id: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'disk_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method unexpose_disk" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `unexpose_disk`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `unexpose_disk`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `unexpose_disk`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/exposed-disks/{disk_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def upate_objectspace_note(self, customer_id, objectspace_id, note_id, payload, **kwargs):  # noqa: E501
        """upate_objectspace_note  # noqa: E501

        Update objectspace note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upate_objectspace_note(customer_id, objectspace_id, note_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str note_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.upate_objectspace_note_with_http_info(customer_id, objectspace_id, note_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.upate_objectspace_note_with_http_info(customer_id, objectspace_id, note_id, payload, **kwargs)  # noqa: E501
            return data

    def upate_objectspace_note_with_http_info(self, customer_id, objectspace_id, note_id, payload, **kwargs):  # noqa: E501
        """upate_objectspace_note  # noqa: E501

        Update objectspace note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upate_objectspace_note_with_http_info(customer_id, objectspace_id, note_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str objectspace_id: (required)
        :param str note_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'objectspace_id', 'note_id', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method upate_objectspace_note" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `upate_objectspace_note`")  # noqa: E501
        # verify the required parameter 'objectspace_id' is set
        if self.api_client.client_side_validation and ('objectspace_id' not in params or
                                                       params['objectspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `objectspace_id` when calling `upate_objectspace_note`")  # noqa: E501
        # verify the required parameter 'note_id' is set
        if self.api_client.client_side_validation and ('note_id' not in params or
                                                       params['note_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `note_id` when calling `upate_objectspace_note`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `upate_objectspace_note`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'objectspace_id' in params:
            path_params['objectspace_id'] = params['objectspace_id']  # noqa: E501
        if 'note_id' in params:
            path_params['note_id'] = params['note_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/objectspaces/{objectspace_id}/notes/{note_id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_certificate(self, customer_id, domain, payload, **kwargs):  # noqa: E501
        """update_certificate  # noqa: E501

        Update certificate information  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_certificate(customer_id, domain, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str domain: (required)
        :param CreateCustomerCertificate payload: (required)
        :param str x_fields: An optional fields mask
        :return: Certificates
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_certificate_with_http_info(customer_id, domain, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.update_certificate_with_http_info(customer_id, domain, payload, **kwargs)  # noqa: E501
            return data

    def update_certificate_with_http_info(self, customer_id, domain, payload, **kwargs):  # noqa: E501
        """update_certificate  # noqa: E501

        Update certificate information  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_certificate_with_http_info(customer_id, domain, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str domain: (required)
        :param CreateCustomerCertificate payload: (required)
        :param str x_fields: An optional fields mask
        :return: Certificates
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'domain', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_certificate" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `update_certificate`")  # noqa: E501
        # verify the required parameter 'domain' is set
        if self.api_client.client_side_validation and ('domain' not in params or
                                                       params['domain'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `domain` when calling `update_certificate`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `update_certificate`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'domain' in params:
            path_params['domain'] = params['domain']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/certificates/ssl/{domain}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Certificates',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_cloudspace_anti_affinity_group(self, customer_id, cloudspace_id, group_id, spread, **kwargs):  # noqa: E501
        """update_cloudspace_anti_affinity_group  # noqa: E501

        Update anti-affinity group rules  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_cloudspace_anti_affinity_group(customer_id, cloudspace_id, group_id, spread, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str group_id: (required)
        :param int spread: Amount of physical nodes to spread vms over. Set to -1 for infinite spread (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_cloudspace_anti_affinity_group_with_http_info(customer_id, cloudspace_id, group_id, spread, **kwargs)  # noqa: E501
        else:
            (data) = self.update_cloudspace_anti_affinity_group_with_http_info(customer_id, cloudspace_id, group_id, spread, **kwargs)  # noqa: E501
            return data

    def update_cloudspace_anti_affinity_group_with_http_info(self, customer_id, cloudspace_id, group_id, spread, **kwargs):  # noqa: E501
        """update_cloudspace_anti_affinity_group  # noqa: E501

        Update anti-affinity group rules  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_cloudspace_anti_affinity_group_with_http_info(customer_id, cloudspace_id, group_id, spread, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str group_id: (required)
        :param int spread: Amount of physical nodes to spread vms over. Set to -1 for infinite spread (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'group_id', 'spread', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_cloudspace_anti_affinity_group" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `update_cloudspace_anti_affinity_group`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `update_cloudspace_anti_affinity_group`")  # noqa: E501
        # verify the required parameter 'group_id' is set
        if self.api_client.client_side_validation and ('group_id' not in params or
                                                       params['group_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `group_id` when calling `update_cloudspace_anti_affinity_group`")  # noqa: E501
        # verify the required parameter 'spread' is set
        if self.api_client.client_side_validation and ('spread' not in params or
                                                       params['spread'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `spread` when calling `update_cloudspace_anti_affinity_group`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'group_id' in params:
            path_params['group_id'] = params['group_id']  # noqa: E501

        query_params = []
        if 'spread' in params:
            query_params.append(('spread', params['spread']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/anti-affinity-groups/{group_id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_cloudspace_external_network_metric(self, customer_id, cloudspace_id, metric, external_network_ip, external_network_id, **kwargs):  # noqa: E501
        """update_cloudspace_external_network_metric  # noqa: E501

        Update cloudspace external network metric  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_cloudspace_external_network_metric(customer_id, cloudspace_id, metric, external_network_ip, external_network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int metric: external network metric(low priority is highest priority)if omitted lowest priority is used (required)
        :param str external_network_ip: optional ip address inside the external network (required)
        :param int external_network_id: optional id to take ip address from.If omited will search for available network (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_cloudspace_external_network_metric_with_http_info(customer_id, cloudspace_id, metric, external_network_ip, external_network_id, **kwargs)  # noqa: E501
        else:
            (data) = self.update_cloudspace_external_network_metric_with_http_info(customer_id, cloudspace_id, metric, external_network_ip, external_network_id, **kwargs)  # noqa: E501
            return data

    def update_cloudspace_external_network_metric_with_http_info(self, customer_id, cloudspace_id, metric, external_network_ip, external_network_id, **kwargs):  # noqa: E501
        """update_cloudspace_external_network_metric  # noqa: E501

        Update cloudspace external network metric  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_cloudspace_external_network_metric_with_http_info(customer_id, cloudspace_id, metric, external_network_ip, external_network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int metric: external network metric(low priority is highest priority)if omitted lowest priority is used (required)
        :param str external_network_ip: optional ip address inside the external network (required)
        :param int external_network_id: optional id to take ip address from.If omited will search for available network (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'metric', 'external_network_ip', 'external_network_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_cloudspace_external_network_metric" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `update_cloudspace_external_network_metric`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `update_cloudspace_external_network_metric`")  # noqa: E501
        # verify the required parameter 'metric' is set
        if self.api_client.client_side_validation and ('metric' not in params or
                                                       params['metric'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `metric` when calling `update_cloudspace_external_network_metric`")  # noqa: E501
        # verify the required parameter 'external_network_ip' is set
        if self.api_client.client_side_validation and ('external_network_ip' not in params or
                                                       params['external_network_ip'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `external_network_ip` when calling `update_cloudspace_external_network_metric`")  # noqa: E501
        # verify the required parameter 'external_network_id' is set
        if self.api_client.client_side_validation and ('external_network_id' not in params or
                                                       params['external_network_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `external_network_id` when calling `update_cloudspace_external_network_metric`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'metric' in params:
            query_params.append(('metric', params['metric']))  # noqa: E501
        if 'external_network_ip' in params:
            query_params.append(('external_network_ip', params['external_network_ip']))  # noqa: E501
        if 'external_network_id' in params:
            query_params.append(('external_network_id', params['external_network_id']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/external-network', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_cloudspace_note(self, customer_id, cloudspace_id, note_id, payload, **kwargs):  # noqa: E501
        """update_cloudspace_note  # noqa: E501

        Update cloudspace note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_cloudspace_note(customer_id, cloudspace_id, note_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str note_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_cloudspace_note_with_http_info(customer_id, cloudspace_id, note_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.update_cloudspace_note_with_http_info(customer_id, cloudspace_id, note_id, payload, **kwargs)  # noqa: E501
            return data

    def update_cloudspace_note_with_http_info(self, customer_id, cloudspace_id, note_id, payload, **kwargs):  # noqa: E501
        """update_cloudspace_note  # noqa: E501

        Update cloudspace note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_cloudspace_note_with_http_info(customer_id, cloudspace_id, note_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str note_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'note_id', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_cloudspace_note" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `update_cloudspace_note`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `update_cloudspace_note`")  # noqa: E501
        # verify the required parameter 'note_id' is set
        if self.api_client.client_side_validation and ('note_id' not in params or
                                                       params['note_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `note_id` when calling `update_cloudspace_note`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `update_cloudspace_note`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'note_id' in params:
            path_params['note_id'] = params['note_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/notes/{note_id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_cloudspace_quota(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """update_cloudspace_quota  # noqa: E501

        Update cloudspace quota  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_cloudspace_quota(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vcpu_quota: VCPU Quota. If omitted the account will be able to provision an unlimited amount of VCPUs.
        :param int vdisk_space_quota: VDisk Quota, If omitted the account will be able to provision an unlimited amount of VDisks.
        :param float memory_quota: Memory Quota, If omitted the account will be able to provision an unlimited amount of Memory.
        :param int public_ip_quota: Public IP Quota, If omitted the account will be able to provision an unlimited amount of Public IPs.
        :param int external_network_quota: External Network Transfer Quota (GB), If omitted the account will be able to provision an unlimited amount of External network transfers.
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_cloudspace_quota_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
        else:
            (data) = self.update_cloudspace_quota_with_http_info(customer_id, cloudspace_id, **kwargs)  # noqa: E501
            return data

    def update_cloudspace_quota_with_http_info(self, customer_id, cloudspace_id, **kwargs):  # noqa: E501
        """update_cloudspace_quota  # noqa: E501

        Update cloudspace quota  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_cloudspace_quota_with_http_info(customer_id, cloudspace_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vcpu_quota: VCPU Quota. If omitted the account will be able to provision an unlimited amount of VCPUs.
        :param int vdisk_space_quota: VDisk Quota, If omitted the account will be able to provision an unlimited amount of VDisks.
        :param float memory_quota: Memory Quota, If omitted the account will be able to provision an unlimited amount of Memory.
        :param int public_ip_quota: Public IP Quota, If omitted the account will be able to provision an unlimited amount of Public IPs.
        :param int external_network_quota: External Network Transfer Quota (GB), If omitted the account will be able to provision an unlimited amount of External network transfers.
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vcpu_quota', 'vdisk_space_quota', 'memory_quota', 'public_ip_quota', 'external_network_quota', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_cloudspace_quota" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `update_cloudspace_quota`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `update_cloudspace_quota`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501

        query_params = []
        if 'vcpu_quota' in params:
            query_params.append(('vcpu_quota', params['vcpu_quota']))  # noqa: E501
        if 'vdisk_space_quota' in params:
            query_params.append(('vdisk_space_quota', params['vdisk_space_quota']))  # noqa: E501
        if 'memory_quota' in params:
            query_params.append(('memory_quota', params['memory_quota']))  # noqa: E501
        if 'public_ip_quota' in params:
            query_params.append(('public_ip_quota', params['public_ip_quota']))  # noqa: E501
        if 'external_network_quota' in params:
            query_params.append(('external_network_quota', params['external_network_quota']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/quota', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_customer(self, customer_id, payload, **kwargs):  # noqa: E501
        """update_customer  # noqa: E501

        Update customer info  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_customer(customer_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param CustomerUpdate payload: (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_customer_with_http_info(customer_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.update_customer_with_http_info(customer_id, payload, **kwargs)  # noqa: E501
            return data

    def update_customer_with_http_info(self, customer_id, payload, **kwargs):  # noqa: E501
        """update_customer  # noqa: E501

        Update customer info  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_customer_with_http_info(customer_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param CustomerUpdate payload: (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'payload']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_customer" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `update_customer`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `update_customer`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_disk_model(self, customer_id, location, disk_id, model, **kwargs):  # noqa: E501
        """update_disk_model  # noqa: E501

        Update Disk Model  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_disk_model(customer_id, location, disk_id, model, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str model: the new NIC model (required)
        :param str x_fields: An optional fields mask
        :return: ChangedModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_disk_model_with_http_info(customer_id, location, disk_id, model, **kwargs)  # noqa: E501
        else:
            (data) = self.update_disk_model_with_http_info(customer_id, location, disk_id, model, **kwargs)  # noqa: E501
            return data

    def update_disk_model_with_http_info(self, customer_id, location, disk_id, model, **kwargs):  # noqa: E501
        """update_disk_model  # noqa: E501

        Update Disk Model  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_disk_model_with_http_info(customer_id, location, disk_id, model, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str model: the new NIC model (required)
        :param str x_fields: An optional fields mask
        :return: ChangedModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'model', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_disk_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `update_disk_model`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `update_disk_model`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `update_disk_model`")  # noqa: E501
        # verify the required parameter 'model' is set
        if self.api_client.client_side_validation and ('model' not in params or
                                                       params['model'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `model` when calling `update_disk_model`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501

        query_params = []
        if 'model' in params:
            query_params.append(('model', params['model']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/model', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ChangedModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_disk_note(self, customer_id, location, disk_id, note_id, payload, **kwargs):  # noqa: E501
        """update_disk_note  # noqa: E501

        Update disk note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_disk_note(customer_id, location, disk_id, note_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str note_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_disk_note_with_http_info(customer_id, location, disk_id, note_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.update_disk_note_with_http_info(customer_id, location, disk_id, note_id, payload, **kwargs)  # noqa: E501
            return data

    def update_disk_note_with_http_info(self, customer_id, location, disk_id, note_id, payload, **kwargs):  # noqa: E501
        """update_disk_note  # noqa: E501

        Update disk note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_disk_note_with_http_info(customer_id, location, disk_id, note_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str location: (required)
        :param int disk_id: (required)
        :param str note_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'location', 'disk_id', 'note_id', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_disk_note" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `update_disk_note`")  # noqa: E501
        # verify the required parameter 'location' is set
        if self.api_client.client_side_validation and ('location' not in params or
                                                       params['location'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `location` when calling `update_disk_note`")  # noqa: E501
        # verify the required parameter 'disk_id' is set
        if self.api_client.client_side_validation and ('disk_id' not in params or
                                                       params['disk_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `disk_id` when calling `update_disk_note`")  # noqa: E501
        # verify the required parameter 'note_id' is set
        if self.api_client.client_side_validation and ('note_id' not in params or
                                                       params['note_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `note_id` when calling `update_disk_note`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `update_disk_note`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'location' in params:
            path_params['location'] = params['location']  # noqa: E501
        if 'disk_id' in params:
            path_params['disk_id'] = params['disk_id']  # noqa: E501
        if 'note_id' in params:
            path_params['note_id'] = params['note_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/locations/{location}/disks/{disk_id}/notes/{note_id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_network_interface_model(self, customer_id, cloudspace_id, vm_id, mac_address, model, **kwargs):  # noqa: E501
        """update_network_interface_model  # noqa: E501

        Update virtual machine network interface model  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_network_interface_model(customer_id, cloudspace_id, vm_id, mac_address, model, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str mac_address: (required)
        :param str model: the new NIC model (required)
        :param str x_fields: An optional fields mask
        :return: ChangedModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_network_interface_model_with_http_info(customer_id, cloudspace_id, vm_id, mac_address, model, **kwargs)  # noqa: E501
        else:
            (data) = self.update_network_interface_model_with_http_info(customer_id, cloudspace_id, vm_id, mac_address, model, **kwargs)  # noqa: E501
            return data

    def update_network_interface_model_with_http_info(self, customer_id, cloudspace_id, vm_id, mac_address, model, **kwargs):  # noqa: E501
        """update_network_interface_model  # noqa: E501

        Update virtual machine network interface model  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_network_interface_model_with_http_info(customer_id, cloudspace_id, vm_id, mac_address, model, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str mac_address: (required)
        :param str model: the new NIC model (required)
        :param str x_fields: An optional fields mask
        :return: ChangedModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'mac_address', 'model', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_network_interface_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `update_network_interface_model`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `update_network_interface_model`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `update_network_interface_model`")  # noqa: E501
        # verify the required parameter 'mac_address' is set
        if self.api_client.client_side_validation and ('mac_address' not in params or
                                                       params['mac_address'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `mac_address` when calling `update_network_interface_model`")  # noqa: E501
        # verify the required parameter 'model' is set
        if self.api_client.client_side_validation and ('model' not in params or
                                                       params['model'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `model` when calling `update_network_interface_model`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501
        if 'mac_address' in params:
            path_params['mac_address'] = params['mac_address']  # noqa: E501

        query_params = []
        if 'model' in params:
            query_params.append(('model', params['model']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/network-interfaces/{mac_address}/model', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ChangedModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_portforward(self, customer_id, cloudspace_id, portforward_id, local_port, public_port, protocol, **kwargs):  # noqa: E501
        """update_portforward  # noqa: E501

        Update cloudspace port forward  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_portforward(customer_id, cloudspace_id, portforward_id, local_port, public_port, protocol, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str portforward_id: (required)
        :param int local_port: Local port (required)
        :param int public_port: Public port (required)
        :param str protocol: Protocol for port forwarding (required)
        :param int vm_id: Virtual Machine ID
        :param int nested_cs_id: Nested Cloudspace ID
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_portforward_with_http_info(customer_id, cloudspace_id, portforward_id, local_port, public_port, protocol, **kwargs)  # noqa: E501
        else:
            (data) = self.update_portforward_with_http_info(customer_id, cloudspace_id, portforward_id, local_port, public_port, protocol, **kwargs)  # noqa: E501
            return data

    def update_portforward_with_http_info(self, customer_id, cloudspace_id, portforward_id, local_port, public_port, protocol, **kwargs):  # noqa: E501
        """update_portforward  # noqa: E501

        Update cloudspace port forward  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_portforward_with_http_info(customer_id, cloudspace_id, portforward_id, local_port, public_port, protocol, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param str portforward_id: (required)
        :param int local_port: Local port (required)
        :param int public_port: Public port (required)
        :param str protocol: Protocol for port forwarding (required)
        :param int vm_id: Virtual Machine ID
        :param int nested_cs_id: Nested Cloudspace ID
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'portforward_id', 'local_port', 'public_port', 'protocol', 'vm_id', 'nested_cs_id', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_portforward" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `update_portforward`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `update_portforward`")  # noqa: E501
        # verify the required parameter 'portforward_id' is set
        if self.api_client.client_side_validation and ('portforward_id' not in params or
                                                       params['portforward_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `portforward_id` when calling `update_portforward`")  # noqa: E501
        # verify the required parameter 'local_port' is set
        if self.api_client.client_side_validation and ('local_port' not in params or
                                                       params['local_port'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `local_port` when calling `update_portforward`")  # noqa: E501
        # verify the required parameter 'public_port' is set
        if self.api_client.client_side_validation and ('public_port' not in params or
                                                       params['public_port'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `public_port` when calling `update_portforward`")  # noqa: E501
        # verify the required parameter 'protocol' is set
        if self.api_client.client_side_validation and ('protocol' not in params or
                                                       params['protocol'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `protocol` when calling `update_portforward`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'portforward_id' in params:
            path_params['portforward_id'] = params['portforward_id']  # noqa: E501

        query_params = []
        if 'local_port' in params:
            query_params.append(('local_port', params['local_port']))  # noqa: E501
        if 'public_port' in params:
            query_params.append(('public_port', params['public_port']))  # noqa: E501
        if 'vm_id' in params:
            query_params.append(('vm_id', params['vm_id']))  # noqa: E501
        if 'nested_cs_id' in params:
            query_params.append(('nested_cs_id', params['nested_cs_id']))  # noqa: E501
        if 'protocol' in params:
            query_params.append(('protocol', params['protocol']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/portforwards/{portforward_id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_role(self, customer_id, role_id, payload, **kwargs):  # noqa: E501
        """update_role  # noqa: E501

        Update customer role  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_role(customer_id, role_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str role_id: (required)
        :param CustomerRoleCreate payload: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_role_with_http_info(customer_id, role_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.update_role_with_http_info(customer_id, role_id, payload, **kwargs)  # noqa: E501
            return data

    def update_role_with_http_info(self, customer_id, role_id, payload, **kwargs):  # noqa: E501
        """update_role  # noqa: E501

        Update customer role  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_role_with_http_info(customer_id, role_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str role_id: (required)
        :param CustomerRoleCreate payload: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'role_id', 'payload']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_role" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `update_role`")  # noqa: E501
        # verify the required parameter 'role_id' is set
        if self.api_client.client_side_validation and ('role_id' not in params or
                                                       params['role_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `role_id` when calling `update_role`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `update_role`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'role_id' in params:
            path_params['role_id'] = params['role_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/roles/{role_id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_role_grants(self, customer_id, role_id, payload, **kwargs):  # noqa: E501
        """update_role_grants  # noqa: E501

        Add/remove role access to a cloud resource  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_role_grants(customer_id, role_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str role_id: (required)
        :param CustomerRoleResourceGrant payload: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_role_grants_with_http_info(customer_id, role_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.update_role_grants_with_http_info(customer_id, role_id, payload, **kwargs)  # noqa: E501
            return data

    def update_role_grants_with_http_info(self, customer_id, role_id, payload, **kwargs):  # noqa: E501
        """update_role_grants  # noqa: E501

        Add/remove role access to a cloud resource  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_role_grants_with_http_info(customer_id, role_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str role_id: (required)
        :param CustomerRoleResourceGrant payload: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'role_id', 'payload']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_role_grants" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `update_role_grants`")  # noqa: E501
        # verify the required parameter 'role_id' is set
        if self.api_client.client_side_validation and ('role_id' not in params or
                                                       params['role_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `role_id` when calling `update_role_grants`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `update_role_grants`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'role_id' in params:
            path_params['role_id'] = params['role_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/roles/{role_id}/grants', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_virtual_machine_description(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """update_virtual_machine_description  # noqa: E501

        Update virtual machine description  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_virtual_machine_description(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str description: Virtual Machine Description
        :param str x_fields: An optional fields mask
        :return: VmIdModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_virtual_machine_description_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
        else:
            (data) = self.update_virtual_machine_description_with_http_info(customer_id, cloudspace_id, vm_id, **kwargs)  # noqa: E501
            return data

    def update_virtual_machine_description_with_http_info(self, customer_id, cloudspace_id, vm_id, **kwargs):  # noqa: E501
        """update_virtual_machine_description  # noqa: E501

        Update virtual machine description  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_virtual_machine_description_with_http_info(customer_id, cloudspace_id, vm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str description: Virtual Machine Description
        :param str x_fields: An optional fields mask
        :return: VmIdModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'description', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_virtual_machine_description" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `update_virtual_machine_description`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `update_virtual_machine_description`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `update_virtual_machine_description`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []
        if 'description' in params:
            query_params.append(('description', params['description']))  # noqa: E501

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/description', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VmIdModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_virtual_machine_note(self, customer_id, cloudspace_id, vm_id, note_id, payload, **kwargs):  # noqa: E501
        """update_virtual_machine_note  # noqa: E501

        Update virtual machine note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_virtual_machine_note(customer_id, cloudspace_id, vm_id, note_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str note_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_virtual_machine_note_with_http_info(customer_id, cloudspace_id, vm_id, note_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.update_virtual_machine_note_with_http_info(customer_id, cloudspace_id, vm_id, note_id, payload, **kwargs)  # noqa: E501
            return data

    def update_virtual_machine_note_with_http_info(self, customer_id, cloudspace_id, vm_id, note_id, payload, **kwargs):  # noqa: E501
        """update_virtual_machine_note  # noqa: E501

        Update virtual machine note  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_virtual_machine_note_with_http_info(customer_id, cloudspace_id, vm_id, note_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param str note_id: (required)
        :param MenejaStructsVcoDataclassesNotesNoteInputsStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'note_id', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_virtual_machine_note" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `update_virtual_machine_note`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `update_virtual_machine_note`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `update_virtual_machine_note`")  # noqa: E501
        # verify the required parameter 'note_id' is set
        if self.api_client.client_side_validation and ('note_id' not in params or
                                                       params['note_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `note_id` when calling `update_virtual_machine_note`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `update_virtual_machine_note`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501
        if 'note_id' in params:
            path_params['note_id'] = params['note_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/notes/{note_id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def write_file(self, customer_id, cloudspace_id, vm_id, payload, **kwargs):  # noqa: E501
        """write_file  # noqa: E501

        Write to file inside virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.write_file(customer_id, cloudspace_id, vm_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param MenejaStructsVcoDataclassesVmVMWriteFileStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.write_file_with_http_info(customer_id, cloudspace_id, vm_id, payload, **kwargs)  # noqa: E501
        else:
            (data) = self.write_file_with_http_info(customer_id, cloudspace_id, vm_id, payload, **kwargs)  # noqa: E501
            return data

    def write_file_with_http_info(self, customer_id, cloudspace_id, vm_id, payload, **kwargs):  # noqa: E501
        """write_file  # noqa: E501

        Write to file inside virtual machine  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.write_file_with_http_info(customer_id, cloudspace_id, vm_id, payload, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str customer_id: (required)
        :param str cloudspace_id: (required)
        :param int vm_id: (required)
        :param MenejaStructsVcoDataclassesVmVMWriteFileStruct payload: (required)
        :param str x_fields: An optional fields mask
        :return: SuccessModel
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['customer_id', 'cloudspace_id', 'vm_id', 'payload', 'x_fields']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method write_file" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'customer_id' is set
        if self.api_client.client_side_validation and ('customer_id' not in params or
                                                       params['customer_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `customer_id` when calling `write_file`")  # noqa: E501
        # verify the required parameter 'cloudspace_id' is set
        if self.api_client.client_side_validation and ('cloudspace_id' not in params or
                                                       params['cloudspace_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `cloudspace_id` when calling `write_file`")  # noqa: E501
        # verify the required parameter 'vm_id' is set
        if self.api_client.client_side_validation and ('vm_id' not in params or
                                                       params['vm_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vm_id` when calling `write_file`")  # noqa: E501
        # verify the required parameter 'payload' is set
        if self.api_client.client_side_validation and ('payload' not in params or
                                                       params['payload'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `payload` when calling `write_file`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'customer_id' in params:
            path_params['customer_id'] = params['customer_id']  # noqa: E501
        if 'cloudspace_id' in params:
            path_params['cloudspace_id'] = params['cloudspace_id']  # noqa: E501
        if 'vm_id' in params:
            path_params['vm_id'] = params['vm_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_fields' in params:
            header_params['X-Fields'] = params['x_fields']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'payload' in params:
            body_params = params['payload']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['Bearer']  # noqa: E501

        return self.api_client.call_api(
            '/customers/{customer_id}/cloudspaces/{cloudspace_id}/vms/{vm_id}/file', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SuccessModel',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)
