text: # coding: utf-8
  
  """
      server
  
      
      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 ncloud_server.api_client import ApiClient
  
  
  class V2Api(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_nas_volume_access_control(self, add_nas_volume_access_control_request, **kwargs):  # noqa: E501
          """add_nas_volume_access_control  # noqa: E501
  
          NAS볼륨인스턴스접근제어추가  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.add_nas_volume_access_control(add_nas_volume_access_control_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param AddNasVolumeAccessControlRequest add_nas_volume_access_control_request: addNasVolumeAccessControlRequest (required)
          :return: AddNasVolumeAccessControlResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.add_nas_volume_access_control_with_http_info(add_nas_volume_access_control_request, **kwargs)  # noqa: E501
          else:
              (data) = self.add_nas_volume_access_control_with_http_info(add_nas_volume_access_control_request, **kwargs)  # noqa: E501
              return data
  
      def add_nas_volume_access_control_with_http_info(self, add_nas_volume_access_control_request, **kwargs):  # noqa: E501
          """add_nas_volume_access_control  # noqa: E501
  
          NAS볼륨인스턴스접근제어추가  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.add_nas_volume_access_control_with_http_info(add_nas_volume_access_control_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param AddNasVolumeAccessControlRequest add_nas_volume_access_control_request: addNasVolumeAccessControlRequest (required)
          :return: AddNasVolumeAccessControlResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['add_nas_volume_access_control_request']  # noqa: E501
          all_params.append('async')
          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_nas_volume_access_control" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'add_nas_volume_access_control_request' is set
          if ('add_nas_volume_access_control_request' not in params or
                  params['add_nas_volume_access_control_request'] is None):
              raise ValueError("Missing the required parameter `add_nas_volume_access_control_request` when calling `add_nas_volume_access_control`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'add_nas_volume_access_control_request' in params:
              body_params = params['add_nas_volume_access_control_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/addNasVolumeAccessControl', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='AddNasVolumeAccessControlResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_port_forwarding_rules(self, add_port_forwarding_rules_request, **kwargs):  # noqa: E501
          """add_port_forwarding_rules  # noqa: E501
  
          포트포워딩Rule추가  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.add_port_forwarding_rules(add_port_forwarding_rules_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param AddPortForwardingRulesRequest add_port_forwarding_rules_request: addPortForwardingRulesRequest (required)
          :return: AddPortForwardingRulesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.add_port_forwarding_rules_with_http_info(add_port_forwarding_rules_request, **kwargs)  # noqa: E501
          else:
              (data) = self.add_port_forwarding_rules_with_http_info(add_port_forwarding_rules_request, **kwargs)  # noqa: E501
              return data
  
      def add_port_forwarding_rules_with_http_info(self, add_port_forwarding_rules_request, **kwargs):  # noqa: E501
          """add_port_forwarding_rules  # noqa: E501
  
          포트포워딩Rule추가  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.add_port_forwarding_rules_with_http_info(add_port_forwarding_rules_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param AddPortForwardingRulesRequest add_port_forwarding_rules_request: addPortForwardingRulesRequest (required)
          :return: AddPortForwardingRulesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['add_port_forwarding_rules_request']  # noqa: E501
          all_params.append('async')
          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_port_forwarding_rules" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'add_port_forwarding_rules_request' is set
          if ('add_port_forwarding_rules_request' not in params or
                  params['add_port_forwarding_rules_request'] is None):
              raise ValueError("Missing the required parameter `add_port_forwarding_rules_request` when calling `add_port_forwarding_rules`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'add_port_forwarding_rules_request' in params:
              body_params = params['add_port_forwarding_rules_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/addPortForwardingRules', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='AddPortForwardingRulesResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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 associate_public_ip_with_server_instance(self, associate_public_ip_with_server_instance_request, **kwargs):  # noqa: E501
          """associate_public_ip_with_server_instance  # noqa: E501
  
          공인IP를서버인스턴스에할당  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.associate_public_ip_with_server_instance(associate_public_ip_with_server_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param AssociatePublicIpWithServerInstanceRequest associate_public_ip_with_server_instance_request: associatePublicIpWithServerInstanceRequest (required)
          :return: AssociatePublicIpWithServerInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.associate_public_ip_with_server_instance_with_http_info(associate_public_ip_with_server_instance_request, **kwargs)  # noqa: E501
          else:
              (data) = self.associate_public_ip_with_server_instance_with_http_info(associate_public_ip_with_server_instance_request, **kwargs)  # noqa: E501
              return data
  
      def associate_public_ip_with_server_instance_with_http_info(self, associate_public_ip_with_server_instance_request, **kwargs):  # noqa: E501
          """associate_public_ip_with_server_instance  # noqa: E501
  
          공인IP를서버인스턴스에할당  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.associate_public_ip_with_server_instance_with_http_info(associate_public_ip_with_server_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param AssociatePublicIpWithServerInstanceRequest associate_public_ip_with_server_instance_request: associatePublicIpWithServerInstanceRequest (required)
          :return: AssociatePublicIpWithServerInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['associate_public_ip_with_server_instance_request']  # noqa: E501
          all_params.append('async')
          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 associate_public_ip_with_server_instance" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'associate_public_ip_with_server_instance_request' is set
          if ('associate_public_ip_with_server_instance_request' not in params or
                  params['associate_public_ip_with_server_instance_request'] is None):
              raise ValueError("Missing the required parameter `associate_public_ip_with_server_instance_request` when calling `associate_public_ip_with_server_instance`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'associate_public_ip_with_server_instance_request' in params:
              body_params = params['associate_public_ip_with_server_instance_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/associatePublicIpWithServerInstance', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='AssociatePublicIpWithServerInstanceResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_block_storage_instance(self, attach_block_storage_instance_request, **kwargs):  # noqa: E501
          """attach_block_storage_instance  # noqa: E501
  
          블록스토리지인스턴스할당  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.attach_block_storage_instance(attach_block_storage_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param AttachBlockStorageInstanceRequest attach_block_storage_instance_request: attachBlockStorageInstanceRequest (required)
          :return: AttachBlockStorageInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.attach_block_storage_instance_with_http_info(attach_block_storage_instance_request, **kwargs)  # noqa: E501
          else:
              (data) = self.attach_block_storage_instance_with_http_info(attach_block_storage_instance_request, **kwargs)  # noqa: E501
              return data
  
      def attach_block_storage_instance_with_http_info(self, attach_block_storage_instance_request, **kwargs):  # noqa: E501
          """attach_block_storage_instance  # noqa: E501
  
          블록스토리지인스턴스할당  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.attach_block_storage_instance_with_http_info(attach_block_storage_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param AttachBlockStorageInstanceRequest attach_block_storage_instance_request: attachBlockStorageInstanceRequest (required)
          :return: AttachBlockStorageInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['attach_block_storage_instance_request']  # noqa: E501
          all_params.append('async')
          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_block_storage_instance" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'attach_block_storage_instance_request' is set
          if ('attach_block_storage_instance_request' not in params or
                  params['attach_block_storage_instance_request'] is None):
              raise ValueError("Missing the required parameter `attach_block_storage_instance_request` when calling `attach_block_storage_instance`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'attach_block_storage_instance_request' in params:
              body_params = params['attach_block_storage_instance_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/attachBlockStorageInstance', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='AttachBlockStorageInstanceResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_network_interface(self, attach_network_interface_request, **kwargs):  # noqa: E501
          """attach_network_interface  # noqa: E501
  
          Network Interface Attach  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.attach_network_interface(attach_network_interface_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param AttachNetworkInterfaceRequest attach_network_interface_request: attachNetworkInterfaceRequest (required)
          :return: AttachNetworkInterfaceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.attach_network_interface_with_http_info(attach_network_interface_request, **kwargs)  # noqa: E501
          else:
              (data) = self.attach_network_interface_with_http_info(attach_network_interface_request, **kwargs)  # noqa: E501
              return data
  
      def attach_network_interface_with_http_info(self, attach_network_interface_request, **kwargs):  # noqa: E501
          """attach_network_interface  # noqa: E501
  
          Network Interface Attach  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.attach_network_interface_with_http_info(attach_network_interface_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param AttachNetworkInterfaceRequest attach_network_interface_request: attachNetworkInterfaceRequest (required)
          :return: AttachNetworkInterfaceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['attach_network_interface_request']  # noqa: E501
          all_params.append('async')
          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_network_interface" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'attach_network_interface_request' is set
          if ('attach_network_interface_request' not in params or
                  params['attach_network_interface_request'] is None):
              raise ValueError("Missing the required parameter `attach_network_interface_request` when calling `attach_network_interface`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'attach_network_interface_request' in params:
              body_params = params['attach_network_interface_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/attachNetworkInterface', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='AttachNetworkInterfaceResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_block_storage_volume_size(self, change_block_storage_volume_size_request, **kwargs):  # noqa: E501
          """change_block_storage_volume_size  # noqa: E501
  
          블록스토리지볼륨사이즈변경  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.change_block_storage_volume_size(change_block_storage_volume_size_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param ChangeBlockStorageVolumeSizeRequest change_block_storage_volume_size_request: changeBlockStorageVolumeSizeRequest (required)
          :return: ChangeBlockStorageVolumeSizeResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.change_block_storage_volume_size_with_http_info(change_block_storage_volume_size_request, **kwargs)  # noqa: E501
          else:
              (data) = self.change_block_storage_volume_size_with_http_info(change_block_storage_volume_size_request, **kwargs)  # noqa: E501
              return data
  
      def change_block_storage_volume_size_with_http_info(self, change_block_storage_volume_size_request, **kwargs):  # noqa: E501
          """change_block_storage_volume_size  # noqa: E501
  
          블록스토리지볼륨사이즈변경  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.change_block_storage_volume_size_with_http_info(change_block_storage_volume_size_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param ChangeBlockStorageVolumeSizeRequest change_block_storage_volume_size_request: changeBlockStorageVolumeSizeRequest (required)
          :return: ChangeBlockStorageVolumeSizeResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['change_block_storage_volume_size_request']  # noqa: E501
          all_params.append('async')
          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_block_storage_volume_size" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'change_block_storage_volume_size_request' is set
          if ('change_block_storage_volume_size_request' not in params or
                  params['change_block_storage_volume_size_request'] is None):
              raise ValueError("Missing the required parameter `change_block_storage_volume_size_request` when calling `change_block_storage_volume_size`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'change_block_storage_volume_size_request' in params:
              body_params = params['change_block_storage_volume_size_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/changeBlockStorageVolumeSize', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ChangeBlockStorageVolumeSizeResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_nas_volume_size(self, change_nas_volume_size_request, **kwargs):  # noqa: E501
          """change_nas_volume_size  # noqa: E501
  
          NAS볼륨사이즈변경  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.change_nas_volume_size(change_nas_volume_size_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param ChangeNasVolumeSizeRequest change_nas_volume_size_request: changeNasVolumeSizeRequest (required)
          :return: ChangeNasVolumeSizeResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.change_nas_volume_size_with_http_info(change_nas_volume_size_request, **kwargs)  # noqa: E501
          else:
              (data) = self.change_nas_volume_size_with_http_info(change_nas_volume_size_request, **kwargs)  # noqa: E501
              return data
  
      def change_nas_volume_size_with_http_info(self, change_nas_volume_size_request, **kwargs):  # noqa: E501
          """change_nas_volume_size  # noqa: E501
  
          NAS볼륨사이즈변경  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.change_nas_volume_size_with_http_info(change_nas_volume_size_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param ChangeNasVolumeSizeRequest change_nas_volume_size_request: changeNasVolumeSizeRequest (required)
          :return: ChangeNasVolumeSizeResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['change_nas_volume_size_request']  # noqa: E501
          all_params.append('async')
          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_nas_volume_size" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'change_nas_volume_size_request' is set
          if ('change_nas_volume_size_request' not in params or
                  params['change_nas_volume_size_request'] is None):
              raise ValueError("Missing the required parameter `change_nas_volume_size_request` when calling `change_nas_volume_size`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'change_nas_volume_size_request' in params:
              body_params = params['change_nas_volume_size_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/changeNasVolumeSize', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ChangeNasVolumeSizeResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_server_instance_spec(self, change_server_instance_spec_request, **kwargs):  # noqa: E501
          """change_server_instance_spec  # noqa: E501
  
          서버인스턴스스팩변경  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.change_server_instance_spec(change_server_instance_spec_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param ChangeServerInstanceSpecRequest change_server_instance_spec_request: changeServerInstanceSpecRequest (required)
          :return: ChangeServerInstanceSpecResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.change_server_instance_spec_with_http_info(change_server_instance_spec_request, **kwargs)  # noqa: E501
          else:
              (data) = self.change_server_instance_spec_with_http_info(change_server_instance_spec_request, **kwargs)  # noqa: E501
              return data
  
      def change_server_instance_spec_with_http_info(self, change_server_instance_spec_request, **kwargs):  # noqa: E501
          """change_server_instance_spec  # noqa: E501
  
          서버인스턴스스팩변경  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.change_server_instance_spec_with_http_info(change_server_instance_spec_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param ChangeServerInstanceSpecRequest change_server_instance_spec_request: changeServerInstanceSpecRequest (required)
          :return: ChangeServerInstanceSpecResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['change_server_instance_spec_request']  # noqa: E501
          all_params.append('async')
          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_server_instance_spec" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'change_server_instance_spec_request' is set
          if ('change_server_instance_spec_request' not in params or
                  params['change_server_instance_spec_request'] is None):
              raise ValueError("Missing the required parameter `change_server_instance_spec_request` when calling `change_server_instance_spec`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'change_server_instance_spec_request' in params:
              body_params = params['change_server_instance_spec_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/changeServerInstanceSpec', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ChangeServerInstanceSpecResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_block_storage_instance(self, create_block_storage_instance_request, **kwargs):  # noqa: E501
          """create_block_storage_instance  # noqa: E501
  
          블록스토리지인스턴스생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_block_storage_instance(create_block_storage_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateBlockStorageInstanceRequest create_block_storage_instance_request: createBlockStorageInstanceRequest (required)
          :return: CreateBlockStorageInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.create_block_storage_instance_with_http_info(create_block_storage_instance_request, **kwargs)  # noqa: E501
          else:
              (data) = self.create_block_storage_instance_with_http_info(create_block_storage_instance_request, **kwargs)  # noqa: E501
              return data
  
      def create_block_storage_instance_with_http_info(self, create_block_storage_instance_request, **kwargs):  # noqa: E501
          """create_block_storage_instance  # noqa: E501
  
          블록스토리지인스턴스생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_block_storage_instance_with_http_info(create_block_storage_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateBlockStorageInstanceRequest create_block_storage_instance_request: createBlockStorageInstanceRequest (required)
          :return: CreateBlockStorageInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['create_block_storage_instance_request']  # noqa: E501
          all_params.append('async')
          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_block_storage_instance" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'create_block_storage_instance_request' is set
          if ('create_block_storage_instance_request' not in params or
                  params['create_block_storage_instance_request'] is None):
              raise ValueError("Missing the required parameter `create_block_storage_instance_request` when calling `create_block_storage_instance`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'create_block_storage_instance_request' in params:
              body_params = params['create_block_storage_instance_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/createBlockStorageInstance', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='CreateBlockStorageInstanceResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_block_storage_snapshot_instance(self, create_block_storage_snapshot_instance_request, **kwargs):  # noqa: E501
          """create_block_storage_snapshot_instance  # noqa: E501
  
          블록스토리지스냅샷인스턴스생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_block_storage_snapshot_instance(create_block_storage_snapshot_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateBlockStorageSnapshotInstanceRequest create_block_storage_snapshot_instance_request: createBlockStorageSnapshotInstanceRequest (required)
          :return: CreateBlockStorageSnapshotInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.create_block_storage_snapshot_instance_with_http_info(create_block_storage_snapshot_instance_request, **kwargs)  # noqa: E501
          else:
              (data) = self.create_block_storage_snapshot_instance_with_http_info(create_block_storage_snapshot_instance_request, **kwargs)  # noqa: E501
              return data
  
      def create_block_storage_snapshot_instance_with_http_info(self, create_block_storage_snapshot_instance_request, **kwargs):  # noqa: E501
          """create_block_storage_snapshot_instance  # noqa: E501
  
          블록스토리지스냅샷인스턴스생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_block_storage_snapshot_instance_with_http_info(create_block_storage_snapshot_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateBlockStorageSnapshotInstanceRequest create_block_storage_snapshot_instance_request: createBlockStorageSnapshotInstanceRequest (required)
          :return: CreateBlockStorageSnapshotInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['create_block_storage_snapshot_instance_request']  # noqa: E501
          all_params.append('async')
          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_block_storage_snapshot_instance" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'create_block_storage_snapshot_instance_request' is set
          if ('create_block_storage_snapshot_instance_request' not in params or
                  params['create_block_storage_snapshot_instance_request'] is None):
              raise ValueError("Missing the required parameter `create_block_storage_snapshot_instance_request` when calling `create_block_storage_snapshot_instance`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'create_block_storage_snapshot_instance_request' in params:
              body_params = params['create_block_storage_snapshot_instance_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/createBlockStorageSnapshotInstance', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='CreateBlockStorageSnapshotInstanceResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_instance_tags(self, create_instance_tags_request, **kwargs):  # noqa: E501
          """create_instance_tags  # noqa: E501
  
          인스턴스태그생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_instance_tags(create_instance_tags_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateInstanceTagsRequest create_instance_tags_request: createInstanceTagsRequest (required)
          :return: CreateInstanceTagsResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.create_instance_tags_with_http_info(create_instance_tags_request, **kwargs)  # noqa: E501
          else:
              (data) = self.create_instance_tags_with_http_info(create_instance_tags_request, **kwargs)  # noqa: E501
              return data
  
      def create_instance_tags_with_http_info(self, create_instance_tags_request, **kwargs):  # noqa: E501
          """create_instance_tags  # noqa: E501
  
          인스턴스태그생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_instance_tags_with_http_info(create_instance_tags_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateInstanceTagsRequest create_instance_tags_request: createInstanceTagsRequest (required)
          :return: CreateInstanceTagsResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['create_instance_tags_request']  # noqa: E501
          all_params.append('async')
          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_instance_tags" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'create_instance_tags_request' is set
          if ('create_instance_tags_request' not in params or
                  params['create_instance_tags_request'] is None):
              raise ValueError("Missing the required parameter `create_instance_tags_request` when calling `create_instance_tags`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'create_instance_tags_request' in params:
              body_params = params['create_instance_tags_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/createInstanceTags', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='CreateInstanceTagsResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_login_key(self, create_login_key_request, **kwargs):  # noqa: E501
          """create_login_key  # noqa: E501
  
          로그인키생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_login_key(create_login_key_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateLoginKeyRequest create_login_key_request: createLoginKeyRequest (required)
          :return: CreateLoginKeyResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.create_login_key_with_http_info(create_login_key_request, **kwargs)  # noqa: E501
          else:
              (data) = self.create_login_key_with_http_info(create_login_key_request, **kwargs)  # noqa: E501
              return data
  
      def create_login_key_with_http_info(self, create_login_key_request, **kwargs):  # noqa: E501
          """create_login_key  # noqa: E501
  
          로그인키생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_login_key_with_http_info(create_login_key_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateLoginKeyRequest create_login_key_request: createLoginKeyRequest (required)
          :return: CreateLoginKeyResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['create_login_key_request']  # noqa: E501
          all_params.append('async')
          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_login_key" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'create_login_key_request' is set
          if ('create_login_key_request' not in params or
                  params['create_login_key_request'] is None):
              raise ValueError("Missing the required parameter `create_login_key_request` when calling `create_login_key`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'create_login_key_request' in params:
              body_params = params['create_login_key_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/createLoginKey', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='CreateLoginKeyResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_member_server_image(self, create_member_server_image_request, **kwargs):  # noqa: E501
          """create_member_server_image  # noqa: E501
  
          회원서버이미지생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_member_server_image(create_member_server_image_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateMemberServerImageRequest create_member_server_image_request: createMemberServerImageRequest (required)
          :return: CreateMemberServerImageResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.create_member_server_image_with_http_info(create_member_server_image_request, **kwargs)  # noqa: E501
          else:
              (data) = self.create_member_server_image_with_http_info(create_member_server_image_request, **kwargs)  # noqa: E501
              return data
  
      def create_member_server_image_with_http_info(self, create_member_server_image_request, **kwargs):  # noqa: E501
          """create_member_server_image  # noqa: E501
  
          회원서버이미지생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_member_server_image_with_http_info(create_member_server_image_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateMemberServerImageRequest create_member_server_image_request: createMemberServerImageRequest (required)
          :return: CreateMemberServerImageResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['create_member_server_image_request']  # noqa: E501
          all_params.append('async')
          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_member_server_image" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'create_member_server_image_request' is set
          if ('create_member_server_image_request' not in params or
                  params['create_member_server_image_request'] is None):
              raise ValueError("Missing the required parameter `create_member_server_image_request` when calling `create_member_server_image`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'create_member_server_image_request' in params:
              body_params = params['create_member_server_image_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/createMemberServerImage', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='CreateMemberServerImageResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_nas_volume_instance(self, create_nas_volume_instance_request, **kwargs):  # noqa: E501
          """create_nas_volume_instance  # noqa: E501
  
          NAS볼륨인스턴스생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_nas_volume_instance(create_nas_volume_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateNasVolumeInstanceRequest create_nas_volume_instance_request: createNasVolumeInstanceRequest (required)
          :return: CreateNasVolumeInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.create_nas_volume_instance_with_http_info(create_nas_volume_instance_request, **kwargs)  # noqa: E501
          else:
              (data) = self.create_nas_volume_instance_with_http_info(create_nas_volume_instance_request, **kwargs)  # noqa: E501
              return data
  
      def create_nas_volume_instance_with_http_info(self, create_nas_volume_instance_request, **kwargs):  # noqa: E501
          """create_nas_volume_instance  # noqa: E501
  
          NAS볼륨인스턴스생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_nas_volume_instance_with_http_info(create_nas_volume_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateNasVolumeInstanceRequest create_nas_volume_instance_request: createNasVolumeInstanceRequest (required)
          :return: CreateNasVolumeInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['create_nas_volume_instance_request']  # noqa: E501
          all_params.append('async')
          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_nas_volume_instance" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'create_nas_volume_instance_request' is set
          if ('create_nas_volume_instance_request' not in params or
                  params['create_nas_volume_instance_request'] is None):
              raise ValueError("Missing the required parameter `create_nas_volume_instance_request` when calling `create_nas_volume_instance`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'create_nas_volume_instance_request' in params:
              body_params = params['create_nas_volume_instance_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/createNasVolumeInstance', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='CreateNasVolumeInstanceResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_network_interface(self, create_network_interface_request, **kwargs):  # noqa: E501
          """create_network_interface  # noqa: E501
  
          Network Interface 생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_network_interface(create_network_interface_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateNetworkInterfaceRequest create_network_interface_request: createNetworkInterfaceRequest (required)
          :return: CreateNetworkInterfaceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.create_network_interface_with_http_info(create_network_interface_request, **kwargs)  # noqa: E501
          else:
              (data) = self.create_network_interface_with_http_info(create_network_interface_request, **kwargs)  # noqa: E501
              return data
  
      def create_network_interface_with_http_info(self, create_network_interface_request, **kwargs):  # noqa: E501
          """create_network_interface  # noqa: E501
  
          Network Interface 생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_network_interface_with_http_info(create_network_interface_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateNetworkInterfaceRequest create_network_interface_request: createNetworkInterfaceRequest (required)
          :return: CreateNetworkInterfaceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['create_network_interface_request']  # noqa: E501
          all_params.append('async')
          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_network_interface" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'create_network_interface_request' is set
          if ('create_network_interface_request' not in params or
                  params['create_network_interface_request'] is None):
              raise ValueError("Missing the required parameter `create_network_interface_request` when calling `create_network_interface`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'create_network_interface_request' in params:
              body_params = params['create_network_interface_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/createNetworkInterface', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='CreateNetworkInterfaceResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_public_ip_instance(self, create_public_ip_instance_request, **kwargs):  # noqa: E501
          """create_public_ip_instance  # noqa: E501
  
          공인IP인스턴스생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_public_ip_instance(create_public_ip_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreatePublicIpInstanceRequest create_public_ip_instance_request: createPublicIpInstanceRequest (required)
          :return: CreatePublicIpInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.create_public_ip_instance_with_http_info(create_public_ip_instance_request, **kwargs)  # noqa: E501
          else:
              (data) = self.create_public_ip_instance_with_http_info(create_public_ip_instance_request, **kwargs)  # noqa: E501
              return data
  
      def create_public_ip_instance_with_http_info(self, create_public_ip_instance_request, **kwargs):  # noqa: E501
          """create_public_ip_instance  # noqa: E501
  
          공인IP인스턴스생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_public_ip_instance_with_http_info(create_public_ip_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreatePublicIpInstanceRequest create_public_ip_instance_request: createPublicIpInstanceRequest (required)
          :return: CreatePublicIpInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['create_public_ip_instance_request']  # noqa: E501
          all_params.append('async')
          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_public_ip_instance" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'create_public_ip_instance_request' is set
          if ('create_public_ip_instance_request' not in params or
                  params['create_public_ip_instance_request'] is None):
              raise ValueError("Missing the required parameter `create_public_ip_instance_request` when calling `create_public_ip_instance`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'create_public_ip_instance_request' in params:
              body_params = params['create_public_ip_instance_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/createPublicIpInstance', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='CreatePublicIpInstanceResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_server_instances(self, create_server_instances_request, **kwargs):  # noqa: E501
          """create_server_instances  # noqa: E501
  
          서버인스턴스생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_server_instances(create_server_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateServerInstancesRequest create_server_instances_request: createServerInstancesRequest (required)
          :return: CreateServerInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.create_server_instances_with_http_info(create_server_instances_request, **kwargs)  # noqa: E501
          else:
              (data) = self.create_server_instances_with_http_info(create_server_instances_request, **kwargs)  # noqa: E501
              return data
  
      def create_server_instances_with_http_info(self, create_server_instances_request, **kwargs):  # noqa: E501
          """create_server_instances  # noqa: E501
  
          서버인스턴스생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.create_server_instances_with_http_info(create_server_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param CreateServerInstancesRequest create_server_instances_request: createServerInstancesRequest (required)
          :return: CreateServerInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['create_server_instances_request']  # noqa: E501
          all_params.append('async')
          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_server_instances" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'create_server_instances_request' is set
          if ('create_server_instances_request' not in params or
                  params['create_server_instances_request'] is None):
              raise ValueError("Missing the required parameter `create_server_instances_request` when calling `create_server_instances`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'create_server_instances_request' in params:
              body_params = params['create_server_instances_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/createServerInstances', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='CreateServerInstancesResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_block_storage_instances(self, delete_block_storage_instances_request, **kwargs):  # noqa: E501
          """delete_block_storage_instances  # noqa: E501
  
          블록스토리지인스턴스삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_block_storage_instances(delete_block_storage_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeleteBlockStorageInstancesRequest delete_block_storage_instances_request: deleteBlockStorageInstancesRequest (required)
          :return: DeleteBlockStorageInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.delete_block_storage_instances_with_http_info(delete_block_storage_instances_request, **kwargs)  # noqa: E501
          else:
              (data) = self.delete_block_storage_instances_with_http_info(delete_block_storage_instances_request, **kwargs)  # noqa: E501
              return data
  
      def delete_block_storage_instances_with_http_info(self, delete_block_storage_instances_request, **kwargs):  # noqa: E501
          """delete_block_storage_instances  # noqa: E501
  
          블록스토리지인스턴스삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_block_storage_instances_with_http_info(delete_block_storage_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeleteBlockStorageInstancesRequest delete_block_storage_instances_request: deleteBlockStorageInstancesRequest (required)
          :return: DeleteBlockStorageInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['delete_block_storage_instances_request']  # noqa: E501
          all_params.append('async')
          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_block_storage_instances" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'delete_block_storage_instances_request' is set
          if ('delete_block_storage_instances_request' not in params or
                  params['delete_block_storage_instances_request'] is None):
              raise ValueError("Missing the required parameter `delete_block_storage_instances_request` when calling `delete_block_storage_instances`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'delete_block_storage_instances_request' in params:
              body_params = params['delete_block_storage_instances_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/deleteBlockStorageInstances', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DeleteBlockStorageInstancesResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_block_storage_snapshot_instances(self, delete_block_storage_snapshot_instances_request, **kwargs):  # noqa: E501
          """delete_block_storage_snapshot_instances  # noqa: E501
  
          블록스토리지스냅샷인스턴스삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_block_storage_snapshot_instances(delete_block_storage_snapshot_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeleteBlockStorageSnapshotInstancesRequest delete_block_storage_snapshot_instances_request: deleteBlockStorageSnapshotInstancesRequest (required)
          :return: DeleteBlockStorageSnapshotInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.delete_block_storage_snapshot_instances_with_http_info(delete_block_storage_snapshot_instances_request, **kwargs)  # noqa: E501
          else:
              (data) = self.delete_block_storage_snapshot_instances_with_http_info(delete_block_storage_snapshot_instances_request, **kwargs)  # noqa: E501
              return data
  
      def delete_block_storage_snapshot_instances_with_http_info(self, delete_block_storage_snapshot_instances_request, **kwargs):  # noqa: E501
          """delete_block_storage_snapshot_instances  # noqa: E501
  
          블록스토리지스냅샷인스턴스삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_block_storage_snapshot_instances_with_http_info(delete_block_storage_snapshot_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeleteBlockStorageSnapshotInstancesRequest delete_block_storage_snapshot_instances_request: deleteBlockStorageSnapshotInstancesRequest (required)
          :return: DeleteBlockStorageSnapshotInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['delete_block_storage_snapshot_instances_request']  # noqa: E501
          all_params.append('async')
          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_block_storage_snapshot_instances" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'delete_block_storage_snapshot_instances_request' is set
          if ('delete_block_storage_snapshot_instances_request' not in params or
                  params['delete_block_storage_snapshot_instances_request'] is None):
              raise ValueError("Missing the required parameter `delete_block_storage_snapshot_instances_request` when calling `delete_block_storage_snapshot_instances`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'delete_block_storage_snapshot_instances_request' in params:
              body_params = params['delete_block_storage_snapshot_instances_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/deleteBlockStorageSnapshotInstances', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DeleteBlockStorageSnapshotInstancesResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_instance_tags(self, delete_instance_tags_request, **kwargs):  # noqa: E501
          """delete_instance_tags  # noqa: E501
  
          인스턴스태그삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_instance_tags(delete_instance_tags_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeleteInstanceTagsRequest delete_instance_tags_request: deleteInstanceTagsRequest (required)
          :return: DeleteInstanceTagsResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.delete_instance_tags_with_http_info(delete_instance_tags_request, **kwargs)  # noqa: E501
          else:
              (data) = self.delete_instance_tags_with_http_info(delete_instance_tags_request, **kwargs)  # noqa: E501
              return data
  
      def delete_instance_tags_with_http_info(self, delete_instance_tags_request, **kwargs):  # noqa: E501
          """delete_instance_tags  # noqa: E501
  
          인스턴스태그삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_instance_tags_with_http_info(delete_instance_tags_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeleteInstanceTagsRequest delete_instance_tags_request: deleteInstanceTagsRequest (required)
          :return: DeleteInstanceTagsResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['delete_instance_tags_request']  # noqa: E501
          all_params.append('async')
          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_instance_tags" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'delete_instance_tags_request' is set
          if ('delete_instance_tags_request' not in params or
                  params['delete_instance_tags_request'] is None):
              raise ValueError("Missing the required parameter `delete_instance_tags_request` when calling `delete_instance_tags`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'delete_instance_tags_request' in params:
              body_params = params['delete_instance_tags_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/deleteInstanceTags', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DeleteInstanceTagsResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_login_key(self, delete_login_key_request, **kwargs):  # noqa: E501
          """delete_login_key  # noqa: E501
  
          로그인키삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_login_key(delete_login_key_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeleteLoginKeyRequest delete_login_key_request: deleteLoginKeyRequest (required)
          :return: DeleteLoginKeyResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.delete_login_key_with_http_info(delete_login_key_request, **kwargs)  # noqa: E501
          else:
              (data) = self.delete_login_key_with_http_info(delete_login_key_request, **kwargs)  # noqa: E501
              return data
  
      def delete_login_key_with_http_info(self, delete_login_key_request, **kwargs):  # noqa: E501
          """delete_login_key  # noqa: E501
  
          로그인키삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_login_key_with_http_info(delete_login_key_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeleteLoginKeyRequest delete_login_key_request: deleteLoginKeyRequest (required)
          :return: DeleteLoginKeyResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['delete_login_key_request']  # noqa: E501
          all_params.append('async')
          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_login_key" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'delete_login_key_request' is set
          if ('delete_login_key_request' not in params or
                  params['delete_login_key_request'] is None):
              raise ValueError("Missing the required parameter `delete_login_key_request` when calling `delete_login_key`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'delete_login_key_request' in params:
              body_params = params['delete_login_key_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/deleteLoginKey', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DeleteLoginKeyResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_member_server_images(self, delete_member_server_images_request, **kwargs):  # noqa: E501
          """delete_member_server_images  # noqa: E501
  
          회원서버이미지삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_member_server_images(delete_member_server_images_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeleteMemberServerImagesRequest delete_member_server_images_request: deleteMemberServerImagesRequest (required)
          :return: DeleteMemberServerImagesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.delete_member_server_images_with_http_info(delete_member_server_images_request, **kwargs)  # noqa: E501
          else:
              (data) = self.delete_member_server_images_with_http_info(delete_member_server_images_request, **kwargs)  # noqa: E501
              return data
  
      def delete_member_server_images_with_http_info(self, delete_member_server_images_request, **kwargs):  # noqa: E501
          """delete_member_server_images  # noqa: E501
  
          회원서버이미지삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_member_server_images_with_http_info(delete_member_server_images_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeleteMemberServerImagesRequest delete_member_server_images_request: deleteMemberServerImagesRequest (required)
          :return: DeleteMemberServerImagesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['delete_member_server_images_request']  # noqa: E501
          all_params.append('async')
          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_member_server_images" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'delete_member_server_images_request' is set
          if ('delete_member_server_images_request' not in params or
                  params['delete_member_server_images_request'] is None):
              raise ValueError("Missing the required parameter `delete_member_server_images_request` when calling `delete_member_server_images`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'delete_member_server_images_request' in params:
              body_params = params['delete_member_server_images_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/deleteMemberServerImages', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DeleteMemberServerImagesResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_nas_volume_instance(self, delete_nas_volume_instance_request, **kwargs):  # noqa: E501
          """delete_nas_volume_instance  # noqa: E501
  
          NAS볼륨인스턴스삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_nas_volume_instance(delete_nas_volume_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeleteNasVolumeInstanceRequest delete_nas_volume_instance_request: deleteNasVolumeInstanceRequest (required)
          :return: DeleteNasVolumeInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.delete_nas_volume_instance_with_http_info(delete_nas_volume_instance_request, **kwargs)  # noqa: E501
          else:
              (data) = self.delete_nas_volume_instance_with_http_info(delete_nas_volume_instance_request, **kwargs)  # noqa: E501
              return data
  
      def delete_nas_volume_instance_with_http_info(self, delete_nas_volume_instance_request, **kwargs):  # noqa: E501
          """delete_nas_volume_instance  # noqa: E501
  
          NAS볼륨인스턴스삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_nas_volume_instance_with_http_info(delete_nas_volume_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeleteNasVolumeInstanceRequest delete_nas_volume_instance_request: deleteNasVolumeInstanceRequest (required)
          :return: DeleteNasVolumeInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['delete_nas_volume_instance_request']  # noqa: E501
          all_params.append('async')
          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_nas_volume_instance" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'delete_nas_volume_instance_request' is set
          if ('delete_nas_volume_instance_request' not in params or
                  params['delete_nas_volume_instance_request'] is None):
              raise ValueError("Missing the required parameter `delete_nas_volume_instance_request` when calling `delete_nas_volume_instance`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'delete_nas_volume_instance_request' in params:
              body_params = params['delete_nas_volume_instance_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/deleteNasVolumeInstance', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DeleteNasVolumeInstanceResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_network_interface(self, delete_network_interface_request, **kwargs):  # noqa: E501
          """delete_network_interface  # noqa: E501
  
          Network Interface 삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_network_interface(delete_network_interface_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeleteNetworkInterfaceRequest delete_network_interface_request: deleteNetworkInterfaceRequest (required)
          :return: DeleteNetworkInterfaceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.delete_network_interface_with_http_info(delete_network_interface_request, **kwargs)  # noqa: E501
          else:
              (data) = self.delete_network_interface_with_http_info(delete_network_interface_request, **kwargs)  # noqa: E501
              return data
  
      def delete_network_interface_with_http_info(self, delete_network_interface_request, **kwargs):  # noqa: E501
          """delete_network_interface  # noqa: E501
  
          Network Interface 삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_network_interface_with_http_info(delete_network_interface_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeleteNetworkInterfaceRequest delete_network_interface_request: deleteNetworkInterfaceRequest (required)
          :return: DeleteNetworkInterfaceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['delete_network_interface_request']  # noqa: E501
          all_params.append('async')
          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_network_interface" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'delete_network_interface_request' is set
          if ('delete_network_interface_request' not in params or
                  params['delete_network_interface_request'] is None):
              raise ValueError("Missing the required parameter `delete_network_interface_request` when calling `delete_network_interface`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'delete_network_interface_request' in params:
              body_params = params['delete_network_interface_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/deleteNetworkInterface', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DeleteNetworkInterfaceResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_port_forwarding_rules(self, delete_port_forwarding_rules_request, **kwargs):  # noqa: E501
          """delete_port_forwarding_rules  # noqa: E501
  
          포트포워딩Rule삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_port_forwarding_rules(delete_port_forwarding_rules_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeletePortForwardingRulesRequest delete_port_forwarding_rules_request: deletePortForwardingRulesRequest (required)
          :return: DeletePortForwardingRulesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.delete_port_forwarding_rules_with_http_info(delete_port_forwarding_rules_request, **kwargs)  # noqa: E501
          else:
              (data) = self.delete_port_forwarding_rules_with_http_info(delete_port_forwarding_rules_request, **kwargs)  # noqa: E501
              return data
  
      def delete_port_forwarding_rules_with_http_info(self, delete_port_forwarding_rules_request, **kwargs):  # noqa: E501
          """delete_port_forwarding_rules  # noqa: E501
  
          포트포워딩Rule삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_port_forwarding_rules_with_http_info(delete_port_forwarding_rules_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeletePortForwardingRulesRequest delete_port_forwarding_rules_request: deletePortForwardingRulesRequest (required)
          :return: DeletePortForwardingRulesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['delete_port_forwarding_rules_request']  # noqa: E501
          all_params.append('async')
          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_port_forwarding_rules" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'delete_port_forwarding_rules_request' is set
          if ('delete_port_forwarding_rules_request' not in params or
                  params['delete_port_forwarding_rules_request'] is None):
              raise ValueError("Missing the required parameter `delete_port_forwarding_rules_request` when calling `delete_port_forwarding_rules`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'delete_port_forwarding_rules_request' in params:
              body_params = params['delete_port_forwarding_rules_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/deletePortForwardingRules', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DeletePortForwardingRulesResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_public_ip_instances(self, delete_public_ip_instances_request, **kwargs):  # noqa: E501
          """delete_public_ip_instances  # noqa: E501
  
          공인IP인스턴스삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_public_ip_instances(delete_public_ip_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeletePublicIpInstancesRequest delete_public_ip_instances_request: deletePublicIpInstancesRequest (required)
          :return: DeletePublicIpInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.delete_public_ip_instances_with_http_info(delete_public_ip_instances_request, **kwargs)  # noqa: E501
          else:
              (data) = self.delete_public_ip_instances_with_http_info(delete_public_ip_instances_request, **kwargs)  # noqa: E501
              return data
  
      def delete_public_ip_instances_with_http_info(self, delete_public_ip_instances_request, **kwargs):  # noqa: E501
          """delete_public_ip_instances  # noqa: E501
  
          공인IP인스턴스삭제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.delete_public_ip_instances_with_http_info(delete_public_ip_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DeletePublicIpInstancesRequest delete_public_ip_instances_request: deletePublicIpInstancesRequest (required)
          :return: DeletePublicIpInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['delete_public_ip_instances_request']  # noqa: E501
          all_params.append('async')
          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_public_ip_instances" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'delete_public_ip_instances_request' is set
          if ('delete_public_ip_instances_request' not in params or
                  params['delete_public_ip_instances_request'] is None):
              raise ValueError("Missing the required parameter `delete_public_ip_instances_request` when calling `delete_public_ip_instances`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'delete_public_ip_instances_request' in params:
              body_params = params['delete_public_ip_instances_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/deletePublicIpInstances', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DeletePublicIpInstancesResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_block_storage_instances(self, detach_block_storage_instances_request, **kwargs):  # noqa: E501
          """detach_block_storage_instances  # noqa: E501
  
          블록스토리지인스턴스할당해제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.detach_block_storage_instances(detach_block_storage_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DetachBlockStorageInstancesRequest detach_block_storage_instances_request: detachBlockStorageInstancesRequest (required)
          :return: DetachBlockStorageInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.detach_block_storage_instances_with_http_info(detach_block_storage_instances_request, **kwargs)  # noqa: E501
          else:
              (data) = self.detach_block_storage_instances_with_http_info(detach_block_storage_instances_request, **kwargs)  # noqa: E501
              return data
  
      def detach_block_storage_instances_with_http_info(self, detach_block_storage_instances_request, **kwargs):  # noqa: E501
          """detach_block_storage_instances  # noqa: E501
  
          블록스토리지인스턴스할당해제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.detach_block_storage_instances_with_http_info(detach_block_storage_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DetachBlockStorageInstancesRequest detach_block_storage_instances_request: detachBlockStorageInstancesRequest (required)
          :return: DetachBlockStorageInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['detach_block_storage_instances_request']  # noqa: E501
          all_params.append('async')
          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_block_storage_instances" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'detach_block_storage_instances_request' is set
          if ('detach_block_storage_instances_request' not in params or
                  params['detach_block_storage_instances_request'] is None):
              raise ValueError("Missing the required parameter `detach_block_storage_instances_request` when calling `detach_block_storage_instances`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'detach_block_storage_instances_request' in params:
              body_params = params['detach_block_storage_instances_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/detachBlockStorageInstances', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DetachBlockStorageInstancesResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_network_interface(self, detach_network_interface_request, **kwargs):  # noqa: E501
          """detach_network_interface  # noqa: E501
  
          Network Interface Detach  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.detach_network_interface(detach_network_interface_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DetachNetworkInterfaceRequest detach_network_interface_request: detachNetworkInterfaceRequest (required)
          :return: DetachNetworkInterfaceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.detach_network_interface_with_http_info(detach_network_interface_request, **kwargs)  # noqa: E501
          else:
              (data) = self.detach_network_interface_with_http_info(detach_network_interface_request, **kwargs)  # noqa: E501
              return data
  
      def detach_network_interface_with_http_info(self, detach_network_interface_request, **kwargs):  # noqa: E501
          """detach_network_interface  # noqa: E501
  
          Network Interface Detach  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.detach_network_interface_with_http_info(detach_network_interface_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DetachNetworkInterfaceRequest detach_network_interface_request: detachNetworkInterfaceRequest (required)
          :return: DetachNetworkInterfaceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['detach_network_interface_request']  # noqa: E501
          all_params.append('async')
          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_network_interface" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'detach_network_interface_request' is set
          if ('detach_network_interface_request' not in params or
                  params['detach_network_interface_request'] is None):
              raise ValueError("Missing the required parameter `detach_network_interface_request` when calling `detach_network_interface`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'detach_network_interface_request' in params:
              body_params = params['detach_network_interface_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/detachNetworkInterface', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DetachNetworkInterfaceResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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 disassociate_public_ip_from_server_instance(self, disassociate_public_ip_from_server_instance_request, **kwargs):  # noqa: E501
          """disassociate_public_ip_from_server_instance  # noqa: E501
  
          공인IP를서버인스턴스에할당해제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.disassociate_public_ip_from_server_instance(disassociate_public_ip_from_server_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DisassociatePublicIpFromServerInstanceRequest disassociate_public_ip_from_server_instance_request: disassociatePublicIpFromServerInstanceRequest (required)
          :return: DisassociatePublicIpFromServerInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.disassociate_public_ip_from_server_instance_with_http_info(disassociate_public_ip_from_server_instance_request, **kwargs)  # noqa: E501
          else:
              (data) = self.disassociate_public_ip_from_server_instance_with_http_info(disassociate_public_ip_from_server_instance_request, **kwargs)  # noqa: E501
              return data
  
      def disassociate_public_ip_from_server_instance_with_http_info(self, disassociate_public_ip_from_server_instance_request, **kwargs):  # noqa: E501
          """disassociate_public_ip_from_server_instance  # noqa: E501
  
          공인IP를서버인스턴스에할당해제  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.disassociate_public_ip_from_server_instance_with_http_info(disassociate_public_ip_from_server_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param DisassociatePublicIpFromServerInstanceRequest disassociate_public_ip_from_server_instance_request: disassociatePublicIpFromServerInstanceRequest (required)
          :return: DisassociatePublicIpFromServerInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['disassociate_public_ip_from_server_instance_request']  # noqa: E501
          all_params.append('async')
          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 disassociate_public_ip_from_server_instance" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'disassociate_public_ip_from_server_instance_request' is set
          if ('disassociate_public_ip_from_server_instance_request' not in params or
                  params['disassociate_public_ip_from_server_instance_request'] is None):
              raise ValueError("Missing the required parameter `disassociate_public_ip_from_server_instance_request` when calling `disassociate_public_ip_from_server_instance`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'disassociate_public_ip_from_server_instance_request' in params:
              body_params = params['disassociate_public_ip_from_server_instance_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/disassociatePublicIpFromServerInstance', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='DisassociatePublicIpFromServerInstanceResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_access_control_group_list(self, get_access_control_group_list_request, **kwargs):  # noqa: E501
          """get_access_control_group_list  # noqa: E501
  
          접근제어그룹리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_access_control_group_list(get_access_control_group_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetAccessControlGroupListRequest get_access_control_group_list_request: getAccessControlGroupListRequest (required)
          :return: GetAccessControlGroupListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_access_control_group_list_with_http_info(get_access_control_group_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_access_control_group_list_with_http_info(get_access_control_group_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_access_control_group_list_with_http_info(self, get_access_control_group_list_request, **kwargs):  # noqa: E501
          """get_access_control_group_list  # noqa: E501
  
          접근제어그룹리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_access_control_group_list_with_http_info(get_access_control_group_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetAccessControlGroupListRequest get_access_control_group_list_request: getAccessControlGroupListRequest (required)
          :return: GetAccessControlGroupListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_access_control_group_list_request']  # noqa: E501
          all_params.append('async')
          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_access_control_group_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_access_control_group_list_request' is set
          if ('get_access_control_group_list_request' not in params or
                  params['get_access_control_group_list_request'] is None):
              raise ValueError("Missing the required parameter `get_access_control_group_list_request` when calling `get_access_control_group_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_access_control_group_list_request' in params:
              body_params = params['get_access_control_group_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getAccessControlGroupList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetAccessControlGroupListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_access_control_group_server_instance_list(self, get_access_control_group_server_instance_list_request, **kwargs):  # noqa: E501
          """get_access_control_group_server_instance_list  # noqa: E501
  
          접근제어그룹적용된서버인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_access_control_group_server_instance_list(get_access_control_group_server_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetAccessControlGroupServerInstanceListRequest get_access_control_group_server_instance_list_request: getAccessControlGroupServerInstanceListRequest (required)
          :return: GetAccessControlGroupServerInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_access_control_group_server_instance_list_with_http_info(get_access_control_group_server_instance_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_access_control_group_server_instance_list_with_http_info(get_access_control_group_server_instance_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_access_control_group_server_instance_list_with_http_info(self, get_access_control_group_server_instance_list_request, **kwargs):  # noqa: E501
          """get_access_control_group_server_instance_list  # noqa: E501
  
          접근제어그룹적용된서버인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_access_control_group_server_instance_list_with_http_info(get_access_control_group_server_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetAccessControlGroupServerInstanceListRequest get_access_control_group_server_instance_list_request: getAccessControlGroupServerInstanceListRequest (required)
          :return: GetAccessControlGroupServerInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_access_control_group_server_instance_list_request']  # noqa: E501
          all_params.append('async')
          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_access_control_group_server_instance_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_access_control_group_server_instance_list_request' is set
          if ('get_access_control_group_server_instance_list_request' not in params or
                  params['get_access_control_group_server_instance_list_request'] is None):
              raise ValueError("Missing the required parameter `get_access_control_group_server_instance_list_request` when calling `get_access_control_group_server_instance_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_access_control_group_server_instance_list_request' in params:
              body_params = params['get_access_control_group_server_instance_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getAccessControlGroupServerInstanceList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetAccessControlGroupServerInstanceListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_access_control_rule_list(self, get_access_control_rule_list_request, **kwargs):  # noqa: E501
          """get_access_control_rule_list  # noqa: E501
  
          접근제어규칙리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_access_control_rule_list(get_access_control_rule_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetAccessControlRuleListRequest get_access_control_rule_list_request: getAccessControlRuleListRequest (required)
          :return: GetAccessControlRuleListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_access_control_rule_list_with_http_info(get_access_control_rule_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_access_control_rule_list_with_http_info(get_access_control_rule_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_access_control_rule_list_with_http_info(self, get_access_control_rule_list_request, **kwargs):  # noqa: E501
          """get_access_control_rule_list  # noqa: E501
  
          접근제어규칙리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_access_control_rule_list_with_http_info(get_access_control_rule_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetAccessControlRuleListRequest get_access_control_rule_list_request: getAccessControlRuleListRequest (required)
          :return: GetAccessControlRuleListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_access_control_rule_list_request']  # noqa: E501
          all_params.append('async')
          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_access_control_rule_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_access_control_rule_list_request' is set
          if ('get_access_control_rule_list_request' not in params or
                  params['get_access_control_rule_list_request'] is None):
              raise ValueError("Missing the required parameter `get_access_control_rule_list_request` when calling `get_access_control_rule_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_access_control_rule_list_request' in params:
              body_params = params['get_access_control_rule_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getAccessControlRuleList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetAccessControlRuleListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_block_storage_instance_list(self, get_block_storage_instance_list_request, **kwargs):  # noqa: E501
          """get_block_storage_instance_list  # noqa: E501
  
          블록스토리지인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_block_storage_instance_list(get_block_storage_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetBlockStorageInstanceListRequest get_block_storage_instance_list_request: getBlockStorageInstanceListRequest (required)
          :return: GetBlockStorageInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_block_storage_instance_list_with_http_info(get_block_storage_instance_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_block_storage_instance_list_with_http_info(get_block_storage_instance_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_block_storage_instance_list_with_http_info(self, get_block_storage_instance_list_request, **kwargs):  # noqa: E501
          """get_block_storage_instance_list  # noqa: E501
  
          블록스토리지인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_block_storage_instance_list_with_http_info(get_block_storage_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetBlockStorageInstanceListRequest get_block_storage_instance_list_request: getBlockStorageInstanceListRequest (required)
          :return: GetBlockStorageInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_block_storage_instance_list_request']  # noqa: E501
          all_params.append('async')
          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_block_storage_instance_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_block_storage_instance_list_request' is set
          if ('get_block_storage_instance_list_request' not in params or
                  params['get_block_storage_instance_list_request'] is None):
              raise ValueError("Missing the required parameter `get_block_storage_instance_list_request` when calling `get_block_storage_instance_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_block_storage_instance_list_request' in params:
              body_params = params['get_block_storage_instance_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getBlockStorageInstanceList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetBlockStorageInstanceListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_block_storage_snapshot_instance_list(self, get_block_storage_snapshot_instance_list_request, **kwargs):  # noqa: E501
          """get_block_storage_snapshot_instance_list  # noqa: E501
  
          블록스토리지스냅샷인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_block_storage_snapshot_instance_list(get_block_storage_snapshot_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetBlockStorageSnapshotInstanceListRequest get_block_storage_snapshot_instance_list_request: getBlockStorageSnapshotInstanceListRequest (required)
          :return: GetBlockStorageSnapshotInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_block_storage_snapshot_instance_list_with_http_info(get_block_storage_snapshot_instance_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_block_storage_snapshot_instance_list_with_http_info(get_block_storage_snapshot_instance_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_block_storage_snapshot_instance_list_with_http_info(self, get_block_storage_snapshot_instance_list_request, **kwargs):  # noqa: E501
          """get_block_storage_snapshot_instance_list  # noqa: E501
  
          블록스토리지스냅샷인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_block_storage_snapshot_instance_list_with_http_info(get_block_storage_snapshot_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetBlockStorageSnapshotInstanceListRequest get_block_storage_snapshot_instance_list_request: getBlockStorageSnapshotInstanceListRequest (required)
          :return: GetBlockStorageSnapshotInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_block_storage_snapshot_instance_list_request']  # noqa: E501
          all_params.append('async')
          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_block_storage_snapshot_instance_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_block_storage_snapshot_instance_list_request' is set
          if ('get_block_storage_snapshot_instance_list_request' not in params or
                  params['get_block_storage_snapshot_instance_list_request'] is None):
              raise ValueError("Missing the required parameter `get_block_storage_snapshot_instance_list_request` when calling `get_block_storage_snapshot_instance_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_block_storage_snapshot_instance_list_request' in params:
              body_params = params['get_block_storage_snapshot_instance_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getBlockStorageSnapshotInstanceList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetBlockStorageSnapshotInstanceListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_init_script_list(self, get_init_script_list_rqeust, **kwargs):  # noqa: E501
          """get_init_script_list  # noqa: E501
  
          초기화스크립트리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_init_script_list(get_init_script_list_rqeust, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetInitScriptListRequest get_init_script_list_rqeust: getInitScriptListRqeust (required)
          :return: GetInitScriptListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_init_script_list_with_http_info(get_init_script_list_rqeust, **kwargs)  # noqa: E501
          else:
              (data) = self.get_init_script_list_with_http_info(get_init_script_list_rqeust, **kwargs)  # noqa: E501
              return data
  
      def get_init_script_list_with_http_info(self, get_init_script_list_rqeust, **kwargs):  # noqa: E501
          """get_init_script_list  # noqa: E501
  
          초기화스크립트리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_init_script_list_with_http_info(get_init_script_list_rqeust, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetInitScriptListRequest get_init_script_list_rqeust: getInitScriptListRqeust (required)
          :return: GetInitScriptListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_init_script_list_rqeust']  # noqa: E501
          all_params.append('async')
          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_init_script_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_init_script_list_rqeust' is set
          if ('get_init_script_list_rqeust' not in params or
                  params['get_init_script_list_rqeust'] is None):
              raise ValueError("Missing the required parameter `get_init_script_list_rqeust` when calling `get_init_script_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_init_script_list_rqeust' in params:
              body_params = params['get_init_script_list_rqeust']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getInitScriptList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetInitScriptListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_instance_tag_list(self, get_instance_tag_list_request, **kwargs):  # noqa: E501
          """get_instance_tag_list  # noqa: E501
  
          인스턴스태그리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_instance_tag_list(get_instance_tag_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetInstanceTagListRequest get_instance_tag_list_request: getInstanceTagListRequest (required)
          :return: GetInstanceTagListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_instance_tag_list_with_http_info(get_instance_tag_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_instance_tag_list_with_http_info(get_instance_tag_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_instance_tag_list_with_http_info(self, get_instance_tag_list_request, **kwargs):  # noqa: E501
          """get_instance_tag_list  # noqa: E501
  
          인스턴스태그리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_instance_tag_list_with_http_info(get_instance_tag_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetInstanceTagListRequest get_instance_tag_list_request: getInstanceTagListRequest (required)
          :return: GetInstanceTagListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_instance_tag_list_request']  # noqa: E501
          all_params.append('async')
          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_instance_tag_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_instance_tag_list_request' is set
          if ('get_instance_tag_list_request' not in params or
                  params['get_instance_tag_list_request'] is None):
              raise ValueError("Missing the required parameter `get_instance_tag_list_request` when calling `get_instance_tag_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_instance_tag_list_request' in params:
              body_params = params['get_instance_tag_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getInstanceTagList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetInstanceTagListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_login_key_list(self, get_login_key_list_request, **kwargs):  # noqa: E501
          """get_login_key_list  # noqa: E501
  
          로그인키리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_login_key_list(get_login_key_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetLoginKeyListRequest get_login_key_list_request: getLoginKeyListRequest (required)
          :return: GetLoginKeyListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_login_key_list_with_http_info(get_login_key_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_login_key_list_with_http_info(get_login_key_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_login_key_list_with_http_info(self, get_login_key_list_request, **kwargs):  # noqa: E501
          """get_login_key_list  # noqa: E501
  
          로그인키리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_login_key_list_with_http_info(get_login_key_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetLoginKeyListRequest get_login_key_list_request: getLoginKeyListRequest (required)
          :return: GetLoginKeyListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_login_key_list_request']  # noqa: E501
          all_params.append('async')
          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_login_key_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_login_key_list_request' is set
          if ('get_login_key_list_request' not in params or
                  params['get_login_key_list_request'] is None):
              raise ValueError("Missing the required parameter `get_login_key_list_request` when calling `get_login_key_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_login_key_list_request' in params:
              body_params = params['get_login_key_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getLoginKeyList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetLoginKeyListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_member_server_image_list(self, get_member_server_image_list_request, **kwargs):  # noqa: E501
          """get_member_server_image_list  # noqa: E501
  
          회원서버이미지리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_member_server_image_list(get_member_server_image_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetMemberServerImageListRequest get_member_server_image_list_request: getMemberServerImageListRequest (required)
          :return: GetMemberServerImageListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_member_server_image_list_with_http_info(get_member_server_image_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_member_server_image_list_with_http_info(get_member_server_image_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_member_server_image_list_with_http_info(self, get_member_server_image_list_request, **kwargs):  # noqa: E501
          """get_member_server_image_list  # noqa: E501
  
          회원서버이미지리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_member_server_image_list_with_http_info(get_member_server_image_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetMemberServerImageListRequest get_member_server_image_list_request: getMemberServerImageListRequest (required)
          :return: GetMemberServerImageListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_member_server_image_list_request']  # noqa: E501
          all_params.append('async')
          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_member_server_image_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_member_server_image_list_request' is set
          if ('get_member_server_image_list_request' not in params or
                  params['get_member_server_image_list_request'] is None):
              raise ValueError("Missing the required parameter `get_member_server_image_list_request` when calling `get_member_server_image_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_member_server_image_list_request' in params:
              body_params = params['get_member_server_image_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getMemberServerImageList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetMemberServerImageListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_nas_volume_instance_list(self, get_nas_volume_instance_list_request, **kwargs):  # noqa: E501
          """get_nas_volume_instance_list  # noqa: E501
  
          NAS볼륨인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_nas_volume_instance_list(get_nas_volume_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetNasVolumeInstanceListRequest get_nas_volume_instance_list_request: getNasVolumeInstanceListRequest (required)
          :return: GetNasVolumeInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_nas_volume_instance_list_with_http_info(get_nas_volume_instance_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_nas_volume_instance_list_with_http_info(get_nas_volume_instance_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_nas_volume_instance_list_with_http_info(self, get_nas_volume_instance_list_request, **kwargs):  # noqa: E501
          """get_nas_volume_instance_list  # noqa: E501
  
          NAS볼륨인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_nas_volume_instance_list_with_http_info(get_nas_volume_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetNasVolumeInstanceListRequest get_nas_volume_instance_list_request: getNasVolumeInstanceListRequest (required)
          :return: GetNasVolumeInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_nas_volume_instance_list_request']  # noqa: E501
          all_params.append('async')
          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_nas_volume_instance_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_nas_volume_instance_list_request' is set
          if ('get_nas_volume_instance_list_request' not in params or
                  params['get_nas_volume_instance_list_request'] is None):
              raise ValueError("Missing the required parameter `get_nas_volume_instance_list_request` when calling `get_nas_volume_instance_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_nas_volume_instance_list_request' in params:
              body_params = params['get_nas_volume_instance_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getNasVolumeInstanceList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetNasVolumeInstanceListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_nas_volume_instance_rating_list(self, get_nas_volume_instance_rating_list_request, **kwargs):  # noqa: E501
          """get_nas_volume_instance_rating_list  # noqa: E501
  
          NAS볼륨인스턴스측정리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_nas_volume_instance_rating_list(get_nas_volume_instance_rating_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetNasVolumeInstanceRatingListRequest get_nas_volume_instance_rating_list_request: getNasVolumeInstanceRatingListRequest (required)
          :return: GetNasVolumeInstanceRatingListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_nas_volume_instance_rating_list_with_http_info(get_nas_volume_instance_rating_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_nas_volume_instance_rating_list_with_http_info(get_nas_volume_instance_rating_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_nas_volume_instance_rating_list_with_http_info(self, get_nas_volume_instance_rating_list_request, **kwargs):  # noqa: E501
          """get_nas_volume_instance_rating_list  # noqa: E501
  
          NAS볼륨인스턴스측정리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_nas_volume_instance_rating_list_with_http_info(get_nas_volume_instance_rating_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetNasVolumeInstanceRatingListRequest get_nas_volume_instance_rating_list_request: getNasVolumeInstanceRatingListRequest (required)
          :return: GetNasVolumeInstanceRatingListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_nas_volume_instance_rating_list_request']  # noqa: E501
          all_params.append('async')
          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_nas_volume_instance_rating_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_nas_volume_instance_rating_list_request' is set
          if ('get_nas_volume_instance_rating_list_request' not in params or
                  params['get_nas_volume_instance_rating_list_request'] is None):
              raise ValueError("Missing the required parameter `get_nas_volume_instance_rating_list_request` when calling `get_nas_volume_instance_rating_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_nas_volume_instance_rating_list_request' in params:
              body_params = params['get_nas_volume_instance_rating_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getNasVolumeInstanceRatingList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetNasVolumeInstanceRatingListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_network_interface_list(self, get_network_interface_list_request, **kwargs):  # noqa: E501
          """get_network_interface_list  # noqa: E501
  
          Network Interface 리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_network_interface_list(get_network_interface_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetNetworkInterfaceListRequest get_network_interface_list_request: getNetworkInterfaceListRequest (required)
          :return: GetNetworkInterfaceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_network_interface_list_with_http_info(get_network_interface_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_network_interface_list_with_http_info(get_network_interface_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_network_interface_list_with_http_info(self, get_network_interface_list_request, **kwargs):  # noqa: E501
          """get_network_interface_list  # noqa: E501
  
          Network Interface 리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_network_interface_list_with_http_info(get_network_interface_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetNetworkInterfaceListRequest get_network_interface_list_request: getNetworkInterfaceListRequest (required)
          :return: GetNetworkInterfaceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_network_interface_list_request']  # noqa: E501
          all_params.append('async')
          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_network_interface_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_network_interface_list_request' is set
          if ('get_network_interface_list_request' not in params or
                  params['get_network_interface_list_request'] is None):
              raise ValueError("Missing the required parameter `get_network_interface_list_request` when calling `get_network_interface_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_network_interface_list_request' in params:
              body_params = params['get_network_interface_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getNetworkInterfaceList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetNetworkInterfaceListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_port_forwarding_rule_list(self, get_port_forwarding_rule_list_request, **kwargs):  # noqa: E501
          """get_port_forwarding_rule_list  # noqa: E501
  
          포트포워딩Rule리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_port_forwarding_rule_list(get_port_forwarding_rule_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetPortForwardingRuleListRequest get_port_forwarding_rule_list_request: getPortForwardingRuleListRequest (required)
          :return: GetPortForwardingRuleListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_port_forwarding_rule_list_with_http_info(get_port_forwarding_rule_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_port_forwarding_rule_list_with_http_info(get_port_forwarding_rule_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_port_forwarding_rule_list_with_http_info(self, get_port_forwarding_rule_list_request, **kwargs):  # noqa: E501
          """get_port_forwarding_rule_list  # noqa: E501
  
          포트포워딩Rule리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_port_forwarding_rule_list_with_http_info(get_port_forwarding_rule_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetPortForwardingRuleListRequest get_port_forwarding_rule_list_request: getPortForwardingRuleListRequest (required)
          :return: GetPortForwardingRuleListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_port_forwarding_rule_list_request']  # noqa: E501
          all_params.append('async')
          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_port_forwarding_rule_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_port_forwarding_rule_list_request' is set
          if ('get_port_forwarding_rule_list_request' not in params or
                  params['get_port_forwarding_rule_list_request'] is None):
              raise ValueError("Missing the required parameter `get_port_forwarding_rule_list_request` when calling `get_port_forwarding_rule_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_port_forwarding_rule_list_request' in params:
              body_params = params['get_port_forwarding_rule_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getPortForwardingRuleList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetPortForwardingRuleListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_private_subnet_instance_list(self, get_private_subnet_instance_list_request, **kwargs):  # noqa: E501
          """get_private_subnet_instance_list  # noqa: E501
  
          Private Subnet 인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_private_subnet_instance_list(get_private_subnet_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetPrivateSubnetInstanceListRequest get_private_subnet_instance_list_request: getPrivateSubnetInstanceListRequest (required)
          :return: GetPrivateSubnetInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_private_subnet_instance_list_with_http_info(get_private_subnet_instance_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_private_subnet_instance_list_with_http_info(get_private_subnet_instance_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_private_subnet_instance_list_with_http_info(self, get_private_subnet_instance_list_request, **kwargs):  # noqa: E501
          """get_private_subnet_instance_list  # noqa: E501
  
          Private Subnet 인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_private_subnet_instance_list_with_http_info(get_private_subnet_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetPrivateSubnetInstanceListRequest get_private_subnet_instance_list_request: getPrivateSubnetInstanceListRequest (required)
          :return: GetPrivateSubnetInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_private_subnet_instance_list_request']  # noqa: E501
          all_params.append('async')
          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_private_subnet_instance_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_private_subnet_instance_list_request' is set
          if ('get_private_subnet_instance_list_request' not in params or
                  params['get_private_subnet_instance_list_request'] is None):
              raise ValueError("Missing the required parameter `get_private_subnet_instance_list_request` when calling `get_private_subnet_instance_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_private_subnet_instance_list_request' in params:
              body_params = params['get_private_subnet_instance_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getPrivateSubnetInstanceList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetPrivateSubnetInstanceListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_public_ip_instance_list(self, get_public_ip_instance_list_request, **kwargs):  # noqa: E501
          """get_public_ip_instance_list  # noqa: E501
  
          공인IP인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_public_ip_instance_list(get_public_ip_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetPublicIpInstanceListRequest get_public_ip_instance_list_request: getPublicIpInstanceListRequest (required)
          :return: GetPublicIpInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_public_ip_instance_list_with_http_info(get_public_ip_instance_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_public_ip_instance_list_with_http_info(get_public_ip_instance_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_public_ip_instance_list_with_http_info(self, get_public_ip_instance_list_request, **kwargs):  # noqa: E501
          """get_public_ip_instance_list  # noqa: E501
  
          공인IP인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_public_ip_instance_list_with_http_info(get_public_ip_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetPublicIpInstanceListRequest get_public_ip_instance_list_request: getPublicIpInstanceListRequest (required)
          :return: GetPublicIpInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_public_ip_instance_list_request']  # noqa: E501
          all_params.append('async')
          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_public_ip_instance_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_public_ip_instance_list_request' is set
          if ('get_public_ip_instance_list_request' not in params or
                  params['get_public_ip_instance_list_request'] is None):
              raise ValueError("Missing the required parameter `get_public_ip_instance_list_request` when calling `get_public_ip_instance_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_public_ip_instance_list_request' in params:
              body_params = params['get_public_ip_instance_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getPublicIpInstanceList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetPublicIpInstanceListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_public_ip_target_server_instance_list(self, get_public_ip_target_server_instance_list_request, **kwargs):  # noqa: E501
          """get_public_ip_target_server_instance_list  # noqa: E501
  
          공인IP할당(가능)서버인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_public_ip_target_server_instance_list(get_public_ip_target_server_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetPublicIpTargetServerInstanceListRequest get_public_ip_target_server_instance_list_request: getPublicIpTargetServerInstanceListRequest (required)
          :return: GetPublicIpTargetServerInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_public_ip_target_server_instance_list_with_http_info(get_public_ip_target_server_instance_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_public_ip_target_server_instance_list_with_http_info(get_public_ip_target_server_instance_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_public_ip_target_server_instance_list_with_http_info(self, get_public_ip_target_server_instance_list_request, **kwargs):  # noqa: E501
          """get_public_ip_target_server_instance_list  # noqa: E501
  
          공인IP할당(가능)서버인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_public_ip_target_server_instance_list_with_http_info(get_public_ip_target_server_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetPublicIpTargetServerInstanceListRequest get_public_ip_target_server_instance_list_request: getPublicIpTargetServerInstanceListRequest (required)
          :return: GetPublicIpTargetServerInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_public_ip_target_server_instance_list_request']  # noqa: E501
          all_params.append('async')
          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_public_ip_target_server_instance_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_public_ip_target_server_instance_list_request' is set
          if ('get_public_ip_target_server_instance_list_request' not in params or
                  params['get_public_ip_target_server_instance_list_request'] is None):
              raise ValueError("Missing the required parameter `get_public_ip_target_server_instance_list_request` when calling `get_public_ip_target_server_instance_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_public_ip_target_server_instance_list_request' in params:
              body_params = params['get_public_ip_target_server_instance_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getPublicIpTargetServerInstanceList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetPublicIpTargetServerInstanceListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_raid_list(self, get_raid_list_request, **kwargs):  # noqa: E501
          """get_raid_list  # noqa: E501
  
          RAID리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_raid_list(get_raid_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetRaidListRequest get_raid_list_request: getRaidListRequest (required)
          :return: GetRaidListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_raid_list_with_http_info(get_raid_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_raid_list_with_http_info(get_raid_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_raid_list_with_http_info(self, get_raid_list_request, **kwargs):  # noqa: E501
          """get_raid_list  # noqa: E501
  
          RAID리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_raid_list_with_http_info(get_raid_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetRaidListRequest get_raid_list_request: getRaidListRequest (required)
          :return: GetRaidListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_raid_list_request']  # noqa: E501
          all_params.append('async')
          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_raid_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_raid_list_request' is set
          if ('get_raid_list_request' not in params or
                  params['get_raid_list_request'] is None):
              raise ValueError("Missing the required parameter `get_raid_list_request` when calling `get_raid_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_raid_list_request' in params:
              body_params = params['get_raid_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getRaidList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetRaidListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_region_list(self, get_region_list_request, **kwargs):  # noqa: E501
          """get_region_list  # noqa: E501
  
          REGION리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_region_list(get_region_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetRegionListRequest get_region_list_request: getRegionListRequest (required)
          :return: GetRegionListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_region_list_with_http_info(get_region_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_region_list_with_http_info(get_region_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_region_list_with_http_info(self, get_region_list_request, **kwargs):  # noqa: E501
          """get_region_list  # noqa: E501
  
          REGION리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_region_list_with_http_info(get_region_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetRegionListRequest get_region_list_request: getRegionListRequest (required)
          :return: GetRegionListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_region_list_request']  # noqa: E501
          all_params.append('async')
          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_region_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_region_list_request' is set
          if ('get_region_list_request' not in params or
                  params['get_region_list_request'] is None):
              raise ValueError("Missing the required parameter `get_region_list_request` when calling `get_region_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_region_list_request' in params:
              body_params = params['get_region_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getRegionList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetRegionListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_root_password(self, get_root_password_request, **kwargs):  # noqa: E501
          """get_root_password  # noqa: E501
  
          루트패스워드조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_root_password(get_root_password_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetRootPasswordRequest get_root_password_request: getRootPasswordRequest (required)
          :return: GetRootPasswordResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_root_password_with_http_info(get_root_password_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_root_password_with_http_info(get_root_password_request, **kwargs)  # noqa: E501
              return data
  
      def get_root_password_with_http_info(self, get_root_password_request, **kwargs):  # noqa: E501
          """get_root_password  # noqa: E501
  
          루트패스워드조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_root_password_with_http_info(get_root_password_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetRootPasswordRequest get_root_password_request: getRootPasswordRequest (required)
          :return: GetRootPasswordResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_root_password_request']  # noqa: E501
          all_params.append('async')
          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_root_password" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_root_password_request' is set
          if ('get_root_password_request' not in params or
                  params['get_root_password_request'] is None):
              raise ValueError("Missing the required parameter `get_root_password_request` when calling `get_root_password`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_root_password_request' in params:
              body_params = params['get_root_password_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getRootPassword', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetRootPasswordResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_root_password_server_instance_list(self, get_root_password_server_instance_list_request, **kwargs):  # noqa: E501
          """get_root_password_server_instance_list  # noqa: E501
  
          루트패스워드서버인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_root_password_server_instance_list(get_root_password_server_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetRootPasswordServerInstanceListRequest get_root_password_server_instance_list_request: getRootPasswordServerInstanceListRequest (required)
          :return: GetRootPasswordServerInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_root_password_server_instance_list_with_http_info(get_root_password_server_instance_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_root_password_server_instance_list_with_http_info(get_root_password_server_instance_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_root_password_server_instance_list_with_http_info(self, get_root_password_server_instance_list_request, **kwargs):  # noqa: E501
          """get_root_password_server_instance_list  # noqa: E501
  
          루트패스워드서버인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_root_password_server_instance_list_with_http_info(get_root_password_server_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetRootPasswordServerInstanceListRequest get_root_password_server_instance_list_request: getRootPasswordServerInstanceListRequest (required)
          :return: GetRootPasswordServerInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_root_password_server_instance_list_request']  # noqa: E501
          all_params.append('async')
          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_root_password_server_instance_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_root_password_server_instance_list_request' is set
          if ('get_root_password_server_instance_list_request' not in params or
                  params['get_root_password_server_instance_list_request'] is None):
              raise ValueError("Missing the required parameter `get_root_password_server_instance_list_request` when calling `get_root_password_server_instance_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_root_password_server_instance_list_request' in params:
              body_params = params['get_root_password_server_instance_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getRootPasswordServerInstanceList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetRootPasswordServerInstanceListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_server_image_product_list(self, get_server_image_product_list_request, **kwargs):  # noqa: E501
          """get_server_image_product_list  # noqa: E501
  
          서버이미지상품리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_server_image_product_list(get_server_image_product_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetServerImageProductListRequest get_server_image_product_list_request: getServerImageProductListRequest (required)
          :return: GetServerImageProductListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_server_image_product_list_with_http_info(get_server_image_product_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_server_image_product_list_with_http_info(get_server_image_product_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_server_image_product_list_with_http_info(self, get_server_image_product_list_request, **kwargs):  # noqa: E501
          """get_server_image_product_list  # noqa: E501
  
          서버이미지상품리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_server_image_product_list_with_http_info(get_server_image_product_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetServerImageProductListRequest get_server_image_product_list_request: getServerImageProductListRequest (required)
          :return: GetServerImageProductListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_server_image_product_list_request']  # noqa: E501
          all_params.append('async')
          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_server_image_product_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_server_image_product_list_request' is set
          if ('get_server_image_product_list_request' not in params or
                  params['get_server_image_product_list_request'] is None):
              raise ValueError("Missing the required parameter `get_server_image_product_list_request` when calling `get_server_image_product_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_server_image_product_list_request' in params:
              body_params = params['get_server_image_product_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getServerImageProductList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetServerImageProductListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_server_instance_list(self, get_server_instance_list_request, **kwargs):  # noqa: E501
          """get_server_instance_list  # noqa: E501
  
          서버인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_server_instance_list(get_server_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetServerInstanceListRequest get_server_instance_list_request: getServerInstanceListRequest (required)
          :return: GetServerInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_server_instance_list_with_http_info(get_server_instance_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_server_instance_list_with_http_info(get_server_instance_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_server_instance_list_with_http_info(self, get_server_instance_list_request, **kwargs):  # noqa: E501
          """get_server_instance_list  # noqa: E501
  
          서버인스턴스리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_server_instance_list_with_http_info(get_server_instance_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetServerInstanceListRequest get_server_instance_list_request: getServerInstanceListRequest (required)
          :return: GetServerInstanceListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_server_instance_list_request']  # noqa: E501
          all_params.append('async')
          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_server_instance_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_server_instance_list_request' is set
          if ('get_server_instance_list_request' not in params or
                  params['get_server_instance_list_request'] is None):
              raise ValueError("Missing the required parameter `get_server_instance_list_request` when calling `get_server_instance_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_server_instance_list_request' in params:
              body_params = params['get_server_instance_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getServerInstanceList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetServerInstanceListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_server_product_list(self, get_server_product_list_request, **kwargs):  # noqa: E501
          """get_server_product_list  # noqa: E501
  
          서버상품리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_server_product_list(get_server_product_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetServerProductListRequest get_server_product_list_request: getServerProductListRequest (required)
          :return: GetServerProductListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_server_product_list_with_http_info(get_server_product_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_server_product_list_with_http_info(get_server_product_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_server_product_list_with_http_info(self, get_server_product_list_request, **kwargs):  # noqa: E501
          """get_server_product_list  # noqa: E501
  
          서버상품리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_server_product_list_with_http_info(get_server_product_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetServerProductListRequest get_server_product_list_request: getServerProductListRequest (required)
          :return: GetServerProductListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_server_product_list_request']  # noqa: E501
          all_params.append('async')
          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_server_product_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_server_product_list_request' is set
          if ('get_server_product_list_request' not in params or
                  params['get_server_product_list_request'] is None):
              raise ValueError("Missing the required parameter `get_server_product_list_request` when calling `get_server_product_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_server_product_list_request' in params:
              body_params = params['get_server_product_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getServerProductList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetServerProductListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_zone_list(self, get_zone_list_request, **kwargs):  # noqa: E501
          """get_zone_list  # noqa: E501
  
          ZONE리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_zone_list(get_zone_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetZoneListRequest get_zone_list_request: getZoneListRequest (required)
          :return: GetZoneListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.get_zone_list_with_http_info(get_zone_list_request, **kwargs)  # noqa: E501
          else:
              (data) = self.get_zone_list_with_http_info(get_zone_list_request, **kwargs)  # noqa: E501
              return data
  
      def get_zone_list_with_http_info(self, get_zone_list_request, **kwargs):  # noqa: E501
          """get_zone_list  # noqa: E501
  
          ZONE리스트조회  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.get_zone_list_with_http_info(get_zone_list_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param GetZoneListRequest get_zone_list_request: getZoneListRequest (required)
          :return: GetZoneListResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['get_zone_list_request']  # noqa: E501
          all_params.append('async')
          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_zone_list" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'get_zone_list_request' is set
          if ('get_zone_list_request' not in params or
                  params['get_zone_list_request'] is None):
              raise ValueError("Missing the required parameter `get_zone_list_request` when calling `get_zone_list`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'get_zone_list_request' in params:
              body_params = params['get_zone_list_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/getZoneList', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='GetZoneListResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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 import_login_key(self, import_login_key_request, **kwargs):  # noqa: E501
          """import_login_key  # noqa: E501
  
          로그인키IMPORT  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.import_login_key(import_login_key_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param ImportLoginKeyRequest import_login_key_request: importLoginKeyRequest (required)
          :return: ImportLoginKeyResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.import_login_key_with_http_info(import_login_key_request, **kwargs)  # noqa: E501
          else:
              (data) = self.import_login_key_with_http_info(import_login_key_request, **kwargs)  # noqa: E501
              return data
  
      def import_login_key_with_http_info(self, import_login_key_request, **kwargs):  # noqa: E501
          """import_login_key  # noqa: E501
  
          로그인키IMPORT  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.import_login_key_with_http_info(import_login_key_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param ImportLoginKeyRequest import_login_key_request: importLoginKeyRequest (required)
          :return: ImportLoginKeyResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['import_login_key_request']  # noqa: E501
          all_params.append('async')
          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 import_login_key" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'import_login_key_request' is set
          if ('import_login_key_request' not in params or
                  params['import_login_key_request'] is None):
              raise ValueError("Missing the required parameter `import_login_key_request` when calling `import_login_key`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'import_login_key_request' in params:
              body_params = params['import_login_key_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/importLoginKey', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ImportLoginKeyResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_server_instances(self, reboot_server_instances_request, **kwargs):  # noqa: E501
          """reboot_server_instances  # noqa: E501
  
          서버인스턴스재시작  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.reboot_server_instances(reboot_server_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param RebootServerInstancesRequest reboot_server_instances_request: rebootServerInstancesRequest (required)
          :return: RebootServerInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.reboot_server_instances_with_http_info(reboot_server_instances_request, **kwargs)  # noqa: E501
          else:
              (data) = self.reboot_server_instances_with_http_info(reboot_server_instances_request, **kwargs)  # noqa: E501
              return data
  
      def reboot_server_instances_with_http_info(self, reboot_server_instances_request, **kwargs):  # noqa: E501
          """reboot_server_instances  # noqa: E501
  
          서버인스턴스재시작  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.reboot_server_instances_with_http_info(reboot_server_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param RebootServerInstancesRequest reboot_server_instances_request: rebootServerInstancesRequest (required)
          :return: RebootServerInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['reboot_server_instances_request']  # noqa: E501
          all_params.append('async')
          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_server_instances" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'reboot_server_instances_request' is set
          if ('reboot_server_instances_request' not in params or
                  params['reboot_server_instances_request'] is None):
              raise ValueError("Missing the required parameter `reboot_server_instances_request` when calling `reboot_server_instances`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'reboot_server_instances_request' in params:
              body_params = params['reboot_server_instances_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/rebootServerInstances', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='RebootServerInstancesResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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 recreate_server_instance(self, recreate_server_instance_request, **kwargs):  # noqa: E501
          """recreate_server_instance  # noqa: E501
  
          서버인스턴스재생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.recreate_server_instance(recreate_server_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param RecreateServerInstanceRequest recreate_server_instance_request: recreateServerInstanceRequest (required)
          :return: RecreateServerInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.recreate_server_instance_with_http_info(recreate_server_instance_request, **kwargs)  # noqa: E501
          else:
              (data) = self.recreate_server_instance_with_http_info(recreate_server_instance_request, **kwargs)  # noqa: E501
              return data
  
      def recreate_server_instance_with_http_info(self, recreate_server_instance_request, **kwargs):  # noqa: E501
          """recreate_server_instance  # noqa: E501
  
          서버인스턴스재생성  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.recreate_server_instance_with_http_info(recreate_server_instance_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param RecreateServerInstanceRequest recreate_server_instance_request: recreateServerInstanceRequest (required)
          :return: RecreateServerInstanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['recreate_server_instance_request']  # noqa: E501
          all_params.append('async')
          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 recreate_server_instance" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'recreate_server_instance_request' is set
          if ('recreate_server_instance_request' not in params or
                  params['recreate_server_instance_request'] is None):
              raise ValueError("Missing the required parameter `recreate_server_instance_request` when calling `recreate_server_instance`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'recreate_server_instance_request' in params:
              body_params = params['recreate_server_instance_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/recreateServerInstance', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='RecreateServerInstanceResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_nas_volume_access_control(self, remove_nas_volume_access_control_request, **kwargs):  # noqa: E501
          """remove_nas_volume_access_control  # noqa: E501
  
          NAS볼륨인스턴스접근제어제거  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.remove_nas_volume_access_control(remove_nas_volume_access_control_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param RemoveNasVolumeAccessControlRequest remove_nas_volume_access_control_request: removeNasVolumeAccessControlRequest (required)
          :return: RemoveNasVolumeAccessControlResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.remove_nas_volume_access_control_with_http_info(remove_nas_volume_access_control_request, **kwargs)  # noqa: E501
          else:
              (data) = self.remove_nas_volume_access_control_with_http_info(remove_nas_volume_access_control_request, **kwargs)  # noqa: E501
              return data
  
      def remove_nas_volume_access_control_with_http_info(self, remove_nas_volume_access_control_request, **kwargs):  # noqa: E501
          """remove_nas_volume_access_control  # noqa: E501
  
          NAS볼륨인스턴스접근제어제거  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.remove_nas_volume_access_control_with_http_info(remove_nas_volume_access_control_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param RemoveNasVolumeAccessControlRequest remove_nas_volume_access_control_request: removeNasVolumeAccessControlRequest (required)
          :return: RemoveNasVolumeAccessControlResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['remove_nas_volume_access_control_request']  # noqa: E501
          all_params.append('async')
          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_nas_volume_access_control" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'remove_nas_volume_access_control_request' is set
          if ('remove_nas_volume_access_control_request' not in params or
                  params['remove_nas_volume_access_control_request'] is None):
              raise ValueError("Missing the required parameter `remove_nas_volume_access_control_request` when calling `remove_nas_volume_access_control`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'remove_nas_volume_access_control_request' in params:
              body_params = params['remove_nas_volume_access_control_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/removeNasVolumeAccessControl', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='RemoveNasVolumeAccessControlResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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 replace_server_instance_associated_with_public_ip(self, replace_server_instance_associated_with_public_ip_request, **kwargs):  # noqa: E501
          """replace_server_instance_associated_with_public_ip  # noqa: E501
  
          공인IP서버인스턴스교체  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.replace_server_instance_associated_with_public_ip(replace_server_instance_associated_with_public_ip_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param ReplaceServerInstanceAssociatedWithPublicIpRequest replace_server_instance_associated_with_public_ip_request: replaceServerInstanceAssociatedWithPublicIpRequest (required)
          :return: ReplaceServerInstanceAssociatedWithPublicIpResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.replace_server_instance_associated_with_public_ip_with_http_info(replace_server_instance_associated_with_public_ip_request, **kwargs)  # noqa: E501
          else:
              (data) = self.replace_server_instance_associated_with_public_ip_with_http_info(replace_server_instance_associated_with_public_ip_request, **kwargs)  # noqa: E501
              return data
  
      def replace_server_instance_associated_with_public_ip_with_http_info(self, replace_server_instance_associated_with_public_ip_request, **kwargs):  # noqa: E501
          """replace_server_instance_associated_with_public_ip  # noqa: E501
  
          공인IP서버인스턴스교체  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.replace_server_instance_associated_with_public_ip_with_http_info(replace_server_instance_associated_with_public_ip_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param ReplaceServerInstanceAssociatedWithPublicIpRequest replace_server_instance_associated_with_public_ip_request: replaceServerInstanceAssociatedWithPublicIpRequest (required)
          :return: ReplaceServerInstanceAssociatedWithPublicIpResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['replace_server_instance_associated_with_public_ip_request']  # noqa: E501
          all_params.append('async')
          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 replace_server_instance_associated_with_public_ip" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'replace_server_instance_associated_with_public_ip_request' is set
          if ('replace_server_instance_associated_with_public_ip_request' not in params or
                  params['replace_server_instance_associated_with_public_ip_request'] is None):
              raise ValueError("Missing the required parameter `replace_server_instance_associated_with_public_ip_request` when calling `replace_server_instance_associated_with_public_ip`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'replace_server_instance_associated_with_public_ip_request' in params:
              body_params = params['replace_server_instance_associated_with_public_ip_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/replaceServerInstanceAssociatedWithPublicIp', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='ReplaceServerInstanceAssociatedWithPublicIpResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_nas_volume_access_control(self, set_nas_volume_access_control_request, **kwargs):  # noqa: E501
          """set_nas_volume_access_control  # noqa: E501
  
          NAS볼륨인스턴스접근제어설정  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.set_nas_volume_access_control(set_nas_volume_access_control_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param SetNasVolumeAccessControlRequest set_nas_volume_access_control_request: setNasVolumeAccessControlRequest (required)
          :return: SetNasVolumeAccessControlResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.set_nas_volume_access_control_with_http_info(set_nas_volume_access_control_request, **kwargs)  # noqa: E501
          else:
              (data) = self.set_nas_volume_access_control_with_http_info(set_nas_volume_access_control_request, **kwargs)  # noqa: E501
              return data
  
      def set_nas_volume_access_control_with_http_info(self, set_nas_volume_access_control_request, **kwargs):  # noqa: E501
          """set_nas_volume_access_control  # noqa: E501
  
          NAS볼륨인스턴스접근제어설정  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.set_nas_volume_access_control_with_http_info(set_nas_volume_access_control_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param SetNasVolumeAccessControlRequest set_nas_volume_access_control_request: setNasVolumeAccessControlRequest (required)
          :return: SetNasVolumeAccessControlResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['set_nas_volume_access_control_request']  # noqa: E501
          all_params.append('async')
          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_nas_volume_access_control" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'set_nas_volume_access_control_request' is set
          if ('set_nas_volume_access_control_request' not in params or
                  params['set_nas_volume_access_control_request'] is None):
              raise ValueError("Missing the required parameter `set_nas_volume_access_control_request` when calling `set_nas_volume_access_control`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'set_nas_volume_access_control_request' in params:
              body_params = params['set_nas_volume_access_control_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/setNasVolumeAccessControl', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='SetNasVolumeAccessControlResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_server_instances(self, start_server_instances_request, **kwargs):  # noqa: E501
          """start_server_instances  # noqa: E501
  
          서버인스턴스시작  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.start_server_instances(start_server_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param StartServerInstancesRequest start_server_instances_request: startServerInstancesRequest (required)
          :return: StartServerInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.start_server_instances_with_http_info(start_server_instances_request, **kwargs)  # noqa: E501
          else:
              (data) = self.start_server_instances_with_http_info(start_server_instances_request, **kwargs)  # noqa: E501
              return data
  
      def start_server_instances_with_http_info(self, start_server_instances_request, **kwargs):  # noqa: E501
          """start_server_instances  # noqa: E501
  
          서버인스턴스시작  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.start_server_instances_with_http_info(start_server_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param StartServerInstancesRequest start_server_instances_request: startServerInstancesRequest (required)
          :return: StartServerInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['start_server_instances_request']  # noqa: E501
          all_params.append('async')
          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_server_instances" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'start_server_instances_request' is set
          if ('start_server_instances_request' not in params or
                  params['start_server_instances_request'] is None):
              raise ValueError("Missing the required parameter `start_server_instances_request` when calling `start_server_instances`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'start_server_instances_request' in params:
              body_params = params['start_server_instances_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/startServerInstances', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='StartServerInstancesResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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_server_instances(self, stop_server_instances_request, **kwargs):  # noqa: E501
          """stop_server_instances  # noqa: E501
  
          서버인스턴스종료  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.stop_server_instances(stop_server_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param StopServerInstancesRequest stop_server_instances_request: stopServerInstancesRequest (required)
          :return: StopServerInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.stop_server_instances_with_http_info(stop_server_instances_request, **kwargs)  # noqa: E501
          else:
              (data) = self.stop_server_instances_with_http_info(stop_server_instances_request, **kwargs)  # noqa: E501
              return data
  
      def stop_server_instances_with_http_info(self, stop_server_instances_request, **kwargs):  # noqa: E501
          """stop_server_instances  # noqa: E501
  
          서버인스턴스종료  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.stop_server_instances_with_http_info(stop_server_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param StopServerInstancesRequest stop_server_instances_request: stopServerInstancesRequest (required)
          :return: StopServerInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['stop_server_instances_request']  # noqa: E501
          all_params.append('async')
          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_server_instances" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'stop_server_instances_request' is set
          if ('stop_server_instances_request' not in params or
                  params['stop_server_instances_request'] is None):
              raise ValueError("Missing the required parameter `stop_server_instances_request` when calling `stop_server_instances`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'stop_server_instances_request' in params:
              body_params = params['stop_server_instances_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/stopServerInstances', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='StopServerInstancesResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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 terminate_server_instances(self, terminate_server_instances_request, **kwargs):  # noqa: E501
          """terminate_server_instances  # noqa: E501
  
          서버인스턴스반납  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.terminate_server_instances(terminate_server_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param TerminateServerInstancesRequest terminate_server_instances_request: terminateServerInstancesRequest (required)
          :return: TerminateServerInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async'):
              return self.terminate_server_instances_with_http_info(terminate_server_instances_request, **kwargs)  # noqa: E501
          else:
              (data) = self.terminate_server_instances_with_http_info(terminate_server_instances_request, **kwargs)  # noqa: E501
              return data
  
      def terminate_server_instances_with_http_info(self, terminate_server_instances_request, **kwargs):  # noqa: E501
          """terminate_server_instances  # noqa: E501
  
          서버인스턴스반납  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async=True
          >>> thread = api.terminate_server_instances_with_http_info(terminate_server_instances_request, async=True)
          >>> result = thread.get()
  
          :param async bool
          :param TerminateServerInstancesRequest terminate_server_instances_request: terminateServerInstancesRequest (required)
          :return: TerminateServerInstancesResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['terminate_server_instances_request']  # noqa: E501
          all_params.append('async')
          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 terminate_server_instances" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'terminate_server_instances_request' is set
          if ('terminate_server_instances_request' not in params or
                  params['terminate_server_instances_request'] is None):
              raise ValueError("Missing the required parameter `terminate_server_instances_request` when calling `terminate_server_instances`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          query_params.append(('responseFormatType', 'json'))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'terminate_server_instances_request' in params:
              body_params = params['terminate_server_instances_request']
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['x-ncp-iam']  # noqa: E501
  
          return self.api_client.call_api(
              '/terminateServerInstances', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='TerminateServerInstancesResponse',  # noqa: E501
              auth_settings=auth_settings,
              _async=params.get('async'),
              _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)
  