
    ~i@                    J    d Z ddlmZ ddlZddlZddlZ G d de          ZdS )z
    clb

    No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)  # noqa: E501

    OpenAPI spec version: common-version
    
    Generated by: https://github.com/swagger-api/swagger-codegen.git
    )absolute_importNc                   .   e Zd ZdZddZd Zd Zd Zd Zd Z	d	 Z
d
 Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Z d  Z!d! Z"d" Z#d# Z$d$ Z%d% Z&d& Z'd' Z(d( Z)d) Z*d* Z+d+ Z,d, Z-d- Z.d. Z/d/ Z0d0 Z1d1 Z2d2 Z3d3 Z4d4 Z5d5 Z6d6 Z7d7 Z8d8 Z9d9 Z:d: Z;d; Z<d< Z=d= Z>d> Z?d? Z@d@ ZAdA ZBdB ZCdC ZDdD ZEdE ZFdF ZGdG ZHdH ZIdI ZJdJ ZKdK ZLdL ZMdM ZNdN ZOdO ZPdP ZQdQ ZRdR ZSdS ZTdT ZUdU ZVdV ZWdW ZXdX ZYdY ZZdZ Z[d[ Z\d\ Z]d] Z^d^ Z_d_ Z`d` Zada Zbdb Zcdc Zddd Zede Zfdf Zgdg Zhdh Zidi Zjdj Zkdk Zldl Zmdm Zndn Zodo Zpdp Zqdq Zrdr Zsds Ztdt Zudu Zvdv Zwdw Zxdx Zydy Zzdz Z{d{ Z|d| Z}d} Z~d~ Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd ZdS )CLBApizNOTE: 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
    Nc                 >    |t          j                    }|| _        d S N)volcenginesdkcore	ApiClient
api_client)selfr
   s     e/root/.openclaw/workspace/.venvs/ark-sdk/lib/python3.11/site-packages/volcenginesdkclb/api/clb_api.py__init__zCLBApi.__init__   s!    *466J$    c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  add_acl_entries  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_acl_entries(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param AddAclEntriesRequest body: (required)
        :return: AddAclEntriesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        T_return_http_data_only	async_req)getadd_acl_entries_with_http_infor   bodykwargsdatas       r   add_acl_entrieszCLBApi.add_acl_entries$   ]     ,0'(::k"" 	646tFFvFFF8T8HHHHTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  add_acl_entries  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_acl_entries_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param AddAclEntriesRequest body: (required)
        :return: AddAclEntriesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   _preload_content_request_timeoutr   zAGot an unexpected keyword argument '%s' to method add_acl_entriesNzDMissing the required parameter `body` when calling `add_acl_entries`application/jsonAccept
text/plainContent-TypevolcengineSignz-/AddAclEntries/2020-04-01/clb/get/text_plain/GETAddAclEntriesResponseT
r   post_paramsfilesresponse_typeauth_settingsr   r   r   r   collection_formatsappendlocalssix	iteritems	TypeErrorr
   client_side_validation
ValueErrorselect_header_acceptselect_header_content_typecall_apir   r   r   r   
all_paramsparamskeyvalr)   path_paramsquery_paramsheader_paramsform_paramslocal_var_filesbody_paramsr(   s                  r   r   z%CLBApi.add_acl_entries_with_http_info9   s     X
+&&&2333,---,---fX&677 	 	HC*$$1367   F3KK8?1 	evV7K7K7=f~7McdddV .K"&/"F"F #" #"h )-(R(RN) )n% **'';U#!1'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  add_nlb_backend_servers  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_nlb_backend_servers(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param AddNLBBackendServersRequest body: (required)
        :return: AddNLBBackendServersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &add_nlb_backend_servers_with_http_infor   s       r   add_nlb_backend_serverszCLBApi.add_nlb_backend_servers   ]     ,0'(::k"" 	>4>tNNvNNN@T@PPPPTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a   add_nlb_backend_servers  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_nlb_backend_servers_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param AddNLBBackendServersRequest body: (required)
        :return: AddNLBBackendServersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method add_nlb_backend_serversNzLMissing the required parameter `body` when calling `add_nlb_backend_servers`r   r   r   r    r!   z4/AddNLBBackendServers/2020-04-01/clb/get/text_plain/r"   AddNLBBackendServersResponseTr$   r*   r5   s                  r   rA   z-CLBApi.add_nlb_backend_servers_with_http_info        X
+&&&2333,---,---fX&677 	 	HC*$$9;>?   F3KK8?1 	mvV7K7K7=f~7MklllV .K"&/"F"F #" #"h )-(R(RN) )n% **''BE#!8'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a3  add_server_group_backend_servers  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_server_group_backend_servers(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param AddServerGroupBackendServersRequest body: (required)
        :return: AddServerGroupBackendServersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   /add_server_group_backend_servers_with_http_infor   s       r    add_server_group_backend_serversz'CLBApi.add_server_group_backend_servers   _     ,0'(::k"" 	G4GWWPVWWWITI$YYRXYYTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aB  add_server_group_backend_servers  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_server_group_backend_servers_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param AddServerGroupBackendServersRequest body: (required)
        :return: AddServerGroupBackendServersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zRGot an unexpected keyword argument '%s' to method add_server_group_backend_serversNzUMissing the required parameter `body` when calling `add_server_group_backend_servers`r   r   r   r    r!   z</AddServerGroupBackendServers/2020-04-01/clb/get/text_plain/r"   $AddServerGroupBackendServersResponseTr$   r*   r5   s                  r   rH   z6CLBApi.add_server_group_backend_servers_with_http_info   s    X
+&&&2333,---,---fX&677 	 	HC*$$BDGH   F3KK8?1 	vvV7K7K7=f~7MtuuuV .K"&/"F"F #" #"h )-(R(RN) )n% **''JE#!@'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a'  attach_health_check_log_topic  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.attach_health_check_log_topic(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param AttachHealthCheckLogTopicRequest body: (required)
        :return: AttachHealthCheckLogTopicResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   ,attach_health_check_log_topic_with_http_infor   s       r   attach_health_check_log_topicz$CLBApi.attach_health_check_log_topicG  ]     ,0'(::k"" 	D4DTTTVTTTFTFtVVvVVTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a6  attach_health_check_log_topic  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.attach_health_check_log_topic_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param AttachHealthCheckLogTopicRequest body: (required)
        :return: AttachHealthCheckLogTopicResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zOGot an unexpected keyword argument '%s' to method attach_health_check_log_topicNzRMissing the required parameter `body` when calling `attach_health_check_log_topic`r   r   r   r    r!   z9/AttachHealthCheckLogTopic/2020-04-01/clb/get/text_plain/r"   !AttachHealthCheckLogTopicResponseTr$   r*   r5   s                  r   rN   z3CLBApi.attach_health_check_log_topic_with_http_info\      X
+&&&2333,---,---fX&677 	 	HC*$$?ADE   F3KK8?1 	svV7K7K7=f~7MqrrrV .K"&/"F"F #" #"h )-(R(RN) )n% **''G#!='jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a;  convert_load_balancer_billing_type  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.convert_load_balancer_billing_type(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ConvertLoadBalancerBillingTypeRequest body: (required)
        :return: ConvertLoadBalancerBillingTypeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   1convert_load_balancer_billing_type_with_http_infor   s       r   "convert_load_balancer_billing_typez)CLBApi.convert_load_balancer_billing_type  _     ,0'(::k"" 	I4I$YYRXYYYKTKD[[TZ[[TKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aJ  convert_load_balancer_billing_type  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.convert_load_balancer_billing_type_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ConvertLoadBalancerBillingTypeRequest body: (required)
        :return: ConvertLoadBalancerBillingTypeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zTGot an unexpected keyword argument '%s' to method convert_load_balancer_billing_typeNzWMissing the required parameter `body` when calling `convert_load_balancer_billing_type`r   r   r   r    r!   z>/ConvertLoadBalancerBillingType/2020-04-01/clb/get/text_plain/r"   &ConvertLoadBalancerBillingTypeResponseTr$   r*   r5   s                  r   rU   z8CLBApi.convert_load_balancer_billing_type_with_http_info      X
+&&&2333,---,---fX&677 	 	HC*$$DFIJ   F3KK8?1 	xvV7K7K7=f~7MvwwwV .K"&/"F"F #" #"h )-(R(RN) )n% **''Le#!B'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_acl  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_acl(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateAclRequest body: (required)
        :return: CreateAclResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   create_acl_with_http_infor   s       r   
create_aclzCLBApi.create_acl	  ]     ,0'(::k"" 	141$AA&AAA3T3DCCFCCTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  create_acl  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_acl_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateAclRequest body: (required)
        :return: CreateAclResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z<Got an unexpected keyword argument '%s' to method create_aclNz?Missing the required parameter `body` when calling `create_acl`r   r   r   r    r!   z)/CreateAcl/2020-04-01/clb/get/text_plain/r"   CreateAclResponseTr$   r*   r5   s                  r   r\   z CLBApi.create_acl_with_http_info       X
+&&&2333,---,---fX&677 	 	HC*$$,.12   F3KK8?1 	`vV7K7K7=f~7M^___V .K"&/"F"F #" #"h )-(R(RN) )n% **''7#!-'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a/  create_health_check_log_project  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_health_check_log_project(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateHealthCheckLogProjectRequest body: (required)
        :return: CreateHealthCheckLogProjectResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   .create_health_check_log_project_with_http_infor   s       r   create_health_check_log_projectz&CLBApi.create_health_check_log_projectj  ^     ,0'(::k"" 	F4FtVVvVVVHTHXXQWXXTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a>  create_health_check_log_project  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_health_check_log_project_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateHealthCheckLogProjectRequest body: (required)
        :return: CreateHealthCheckLogProjectResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zQGot an unexpected keyword argument '%s' to method create_health_check_log_projectNzTMissing the required parameter `body` when calling `create_health_check_log_project`r   r   r   r    r!   z;/CreateHealthCheckLogProject/2020-04-01/clb/get/text_plain/r"   #CreateHealthCheckLogProjectResponseTr$   r*   r5   s                  r   rc   z5CLBApi.create_health_check_log_project_with_http_info      X
+&&&2333,---,---fX&677 	 	HC*$$ACFG   F3KK8?1 	uvV7K7K7=f~7MstttV .K"&/"F"F #" #"h )-(R(RN) )n% **''I5#!?'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_listener  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_listener(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateListenerRequest body: (required)
        :return: CreateListenerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   create_listener_with_http_infor   s       r   create_listenerzCLBApi.create_listener  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  create_listener  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_listener_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateListenerRequest body: (required)
        :return: CreateListenerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zAGot an unexpected keyword argument '%s' to method create_listenerNzDMissing the required parameter `body` when calling `create_listener`r   r   r   r    r!   z./CreateListener/2020-04-01/clb/get/text_plain/r"   CreateListenerResponseTr$   r*   r5   s                  r   rj   z%CLBApi.create_listener_with_http_info       X
+&&&2333,---,---fX&677 	 	HC*$$1367   F3KK8?1 	evV7K7K7=f~7McdddV .K"&/"F"F #" #"h )-(R(RN) )n% **''<e#!2'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_load_balancer  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_load_balancer(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateLoadBalancerRequest body: (required)
        :return: CreateLoadBalancerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #create_load_balancer_with_http_infor   s       r   create_load_balancerzCLBApi.create_load_balancer,  ]     ,0'(::k"" 	;4;DKKFKKK=T=dMMfMMTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  create_load_balancer  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_load_balancer_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateLoadBalancerRequest body: (required)
        :return: CreateLoadBalancerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method create_load_balancerNzIMissing the required parameter `body` when calling `create_load_balancer`r   r   r   r    r!   z2/CreateLoadBalancer/2020-04-01/clb/get/text_plain/r"   CreateLoadBalancerResponseTr$   r*   r5   s                  r   rp   z*CLBApi.create_load_balancer_with_http_infoA       X
+&&&2333,---,---fX&677 	 	HC*$$68;<   F3KK8?1 	jvV7K7K7=f~7MhiiiV .K"&/"F"F #" #"h )-(R(RN) )n% **''@%#!6'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a%  create_network_load_balancer  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_network_load_balancer(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateNetworkLoadBalancerRequest body: (required)
        :return: CreateNetworkLoadBalancerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   +create_network_load_balancer_with_http_infor   s       r   create_network_load_balancerz#CLBApi.create_network_load_balancer  ]     ,0'(::k"" 	C4CDSSFSSSETEdUUfUUTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a4  create_network_load_balancer  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_network_load_balancer_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateNetworkLoadBalancerRequest body: (required)
        :return: CreateNetworkLoadBalancerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zNGot an unexpected keyword argument '%s' to method create_network_load_balancerNzQMissing the required parameter `body` when calling `create_network_load_balancer`r   r   r   r    r!   z9/CreateNetworkLoadBalancer/2020-04-01/clb/get/text_plain/r"   !CreateNetworkLoadBalancerResponseTr$   r*   r5   s                  r   rw   z2CLBApi.create_network_load_balancer_with_http_info      X
+&&&2333,---,---fX&677 	 	HC*$$>@CD   F3KK8?1 	rvV7K7K7=f~7MpqqqV .K"&/"F"F #" #"h )-(R(RN) )n% **''G#!='jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_nlb_listener  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_nlb_listener(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateNLBListenerRequest body: (required)
        :return: CreateNLBListenerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "create_nlb_listener_with_http_infor   s       r   create_nlb_listenerzCLBApi.create_nlb_listener  ]     ,0'(::k"" 	:4:4JJ6JJJ<T<TLLVLLTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  create_nlb_listener  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_nlb_listener_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateNLBListenerRequest body: (required)
        :return: CreateNLBListenerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zEGot an unexpected keyword argument '%s' to method create_nlb_listenerNzHMissing the required parameter `body` when calling `create_nlb_listener`r   r   r   r    r!   z1/CreateNLBListener/2020-04-01/clb/get/text_plain/r"   CreateNLBListenerResponseTr$   r*   r5   s                  r   r~   z)CLBApi.create_nlb_listener_with_http_info       X
+&&&2333,---,---fX&677 	 	HC*$$57:;   F3KK8?1 	ivV7K7K7=f~7MghhhV .K"&/"F"F #" #"h )-(R(RN) )n% **''?#!5'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_nlb_security_policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_nlb_security_policy(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateNLBSecurityPolicyRequest body: (required)
        :return: CreateNLBSecurityPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )create_nlb_security_policy_with_http_infor   s       r   create_nlb_security_policyz!CLBApi.create_nlb_security_policyO  ]     ,0'(::k"" 	A4A$QQ&QQQCTCDSSFSSTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a,  create_nlb_security_policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_nlb_security_policy_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateNLBSecurityPolicyRequest body: (required)
        :return: CreateNLBSecurityPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method create_nlb_security_policyNzOMissing the required parameter `body` when calling `create_nlb_security_policy`r   r   r   r    r!   z7/CreateNLBSecurityPolicy/2020-04-01/clb/get/text_plain/r"   CreateNLBSecurityPolicyResponseTr$   r*   r5   s                  r   r   z0CLBApi.create_nlb_security_policy_with_http_infod      X
+&&&2333,---,---fX&677 	 	HC*$$<>AB   F3KK8?1 	pvV7K7K7=f~7MnoooV .K"&/"F"F #" #"h )-(R(RN) )n% **''Eu#!;'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_nlb_server_group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_nlb_server_group(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateNLBServerGroupRequest body: (required)
        :return: CreateNLBServerGroupResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &create_nlb_server_group_with_http_infor   s       r   create_nlb_server_groupzCLBApi.create_nlb_server_group  rC   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a   create_nlb_server_group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_nlb_server_group_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateNLBServerGroupRequest body: (required)
        :return: CreateNLBServerGroupResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method create_nlb_server_groupNzLMissing the required parameter `body` when calling `create_nlb_server_group`r   r   r   r    r!   z4/CreateNLBServerGroup/2020-04-01/clb/get/text_plain/r"   CreateNLBServerGroupResponseTr$   r*   r5   s                  r   r   z-CLBApi.create_nlb_server_group_with_http_info  rF   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_rules  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_rules(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateRulesRequest body: (required)
        :return: CreateRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   create_rules_with_http_infor   s       r   create_ruleszCLBApi.create_rules  ]     ,0'(::k"" 	343DCCFCCC5T5dEEfEETKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  create_rules  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_rules_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateRulesRequest body: (required)
        :return: CreateRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z>Got an unexpected keyword argument '%s' to method create_rulesNzAMissing the required parameter `body` when calling `create_rules`r   r   r   r    r!   z+/CreateRules/2020-04-01/clb/get/text_plain/r"   CreateRulesResponseTr$   r*   r5   s                  r   r   z"CLBApi.create_rules_with_http_info&       X
+&&&2333,---,---fX&677 	 	HC*$$.034   F3KK8?1 	bvV7K7K7=f~7M`aaaV .K"&/"F"F #" #"h )-(R(RN) )n% **''95#!/'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_server_group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_server_group(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateServerGroupRequest body: (required)
        :return: CreateServerGroupResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "create_server_group_with_http_infor   s       r   create_server_groupzCLBApi.create_server_groupr  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  create_server_group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_server_group_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateServerGroupRequest body: (required)
        :return: CreateServerGroupResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zEGot an unexpected keyword argument '%s' to method create_server_groupNzHMissing the required parameter `body` when calling `create_server_group`r   r   r   r    r!   z1/CreateServerGroup/2020-04-01/clb/get/text_plain/r"   CreateServerGroupResponseTr$   r*   r5   s                  r   r   z)CLBApi.create_server_group_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_acl  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_acl(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteAclRequest body: (required)
        :return: DeleteAclResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   delete_acl_with_http_infor   s       r   
delete_aclzCLBApi.delete_acl  r^   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  delete_acl  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_acl_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteAclRequest body: (required)
        :return: DeleteAclResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z<Got an unexpected keyword argument '%s' to method delete_aclNz?Missing the required parameter `body` when calling `delete_acl`r   r   r   r    r!   z)/DeleteAcl/2020-04-01/clb/get/text_plain/r"   DeleteAclResponseTr$   r*   r5   s                  r   r   z CLBApi.delete_acl_with_http_info  ra   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_certificate  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_certificate(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteCertificateRequest body: (required)
        :return: DeleteCertificateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !delete_certificate_with_http_infor   s       r   delete_certificatezCLBApi.delete_certificate4  ]     ,0'(::k"" 	949$II&III;T;DKKFKKTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  delete_certificate  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_certificate_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteCertificateRequest body: (required)
        :return: DeleteCertificateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method delete_certificateNzGMissing the required parameter `body` when calling `delete_certificate`r   r   r   r    r!   z1/DeleteCertificate/2020-04-01/clb/get/text_plain/r"   DeleteCertificateResponseTr$   r*   r5   s                  r   r   z(CLBApi.delete_certificate_with_http_infoI       X
+&&&2333,---,---fX&677 	 	HC*$$469:   F3KK8?1 	hvV7K7K7=f~7MfgggV .K"&/"F"F #" #"h )-(R(RN) )n% **''?#!5'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a/  delete_health_check_log_project  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_health_check_log_project(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteHealthCheckLogProjectRequest body: (required)
        :return: DeleteHealthCheckLogProjectResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   .delete_health_check_log_project_with_http_infor   s       r   delete_health_check_log_projectz&CLBApi.delete_health_check_log_project  re   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a>  delete_health_check_log_project  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_health_check_log_project_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteHealthCheckLogProjectRequest body: (required)
        :return: DeleteHealthCheckLogProjectResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zQGot an unexpected keyword argument '%s' to method delete_health_check_log_projectNzTMissing the required parameter `body` when calling `delete_health_check_log_project`r   r   r   r    r!   z;/DeleteHealthCheckLogProject/2020-04-01/clb/get/text_plain/r"   #DeleteHealthCheckLogProjectResponseTr$   r*   r5   s                  r   r   z5CLBApi.delete_health_check_log_project_with_http_info  rh   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_listener  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_listener(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteListenerRequest body: (required)
        :return: DeleteListenerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   delete_listener_with_http_infor   s       r   delete_listenerzCLBApi.delete_listener  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  delete_listener  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_listener_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteListenerRequest body: (required)
        :return: DeleteListenerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zAGot an unexpected keyword argument '%s' to method delete_listenerNzDMissing the required parameter `body` when calling `delete_listener`r   r   r   r    r!   z./DeleteListener/2020-04-01/clb/get/text_plain/r"   DeleteListenerResponseTr$   r*   r5   s                  r   r   z%CLBApi.delete_listener_with_http_info  rn   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_load_balancer  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_load_balancer(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteLoadBalancerRequest body: (required)
        :return: DeleteLoadBalancerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #delete_load_balancer_with_http_infor   s       r   delete_load_balancerzCLBApi.delete_load_balancerW  rr   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  delete_load_balancer  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_load_balancer_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteLoadBalancerRequest body: (required)
        :return: DeleteLoadBalancerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method delete_load_balancerNzIMissing the required parameter `body` when calling `delete_load_balancer`r   r   r   r    r!   z2/DeleteLoadBalancer/2020-04-01/clb/get/text_plain/r"   DeleteLoadBalancerResponseTr$   r*   r5   s                  r   r   z*CLBApi.delete_load_balancer_with_http_infol  ru   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a%  delete_network_load_balancer  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_network_load_balancer(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteNetworkLoadBalancerRequest body: (required)
        :return: DeleteNetworkLoadBalancerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   +delete_network_load_balancer_with_http_infor   s       r   delete_network_load_balancerz#CLBApi.delete_network_load_balancer  ry   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a4  delete_network_load_balancer  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_network_load_balancer_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteNetworkLoadBalancerRequest body: (required)
        :return: DeleteNetworkLoadBalancerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zNGot an unexpected keyword argument '%s' to method delete_network_load_balancerNzQMissing the required parameter `body` when calling `delete_network_load_balancer`r   r   r   r    r!   z9/DeleteNetworkLoadBalancer/2020-04-01/clb/get/text_plain/r"   !DeleteNetworkLoadBalancerResponseTr$   r*   r5   s                  r   r   z2CLBApi.delete_network_load_balancer_with_http_info  r|   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_nlb_listener  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_nlb_listener(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteNLBListenerRequest body: (required)
        :return: DeleteNLBListenerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "delete_nlb_listener_with_http_infor   s       r   delete_nlb_listenerzCLBApi.delete_nlb_listener  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  delete_nlb_listener  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_nlb_listener_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteNLBListenerRequest body: (required)
        :return: DeleteNLBListenerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zEGot an unexpected keyword argument '%s' to method delete_nlb_listenerNzHMissing the required parameter `body` when calling `delete_nlb_listener`r   r   r   r    r!   z1/DeleteNLBListener/2020-04-01/clb/get/text_plain/r"   DeleteNLBListenerResponseTr$   r*   r5   s                  r   r   z)CLBApi.delete_nlb_listener_with_http_info.  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_nlb_security_policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_nlb_security_policy(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteNLBSecurityPolicyRequest body: (required)
        :return: DeleteNLBSecurityPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )delete_nlb_security_policy_with_http_infor   s       r   delete_nlb_security_policyz!CLBApi.delete_nlb_security_policyz  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a,  delete_nlb_security_policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_nlb_security_policy_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteNLBSecurityPolicyRequest body: (required)
        :return: DeleteNLBSecurityPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method delete_nlb_security_policyNzOMissing the required parameter `body` when calling `delete_nlb_security_policy`r   r   r   r    r!   z7/DeleteNLBSecurityPolicy/2020-04-01/clb/get/text_plain/r"   DeleteNLBSecurityPolicyResponseTr$   r*   r5   s                  r   r   z0CLBApi.delete_nlb_security_policy_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_nlb_server_group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_nlb_server_group(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteNLBServerGroupRequest body: (required)
        :return: DeleteNLBServerGroupResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &delete_nlb_server_group_with_http_infor   s       r   delete_nlb_server_groupzCLBApi.delete_nlb_server_group  rC   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a   delete_nlb_server_group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_nlb_server_group_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteNLBServerGroupRequest body: (required)
        :return: DeleteNLBServerGroupResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method delete_nlb_server_groupNzLMissing the required parameter `body` when calling `delete_nlb_server_group`r   r   r   r    r!   z4/DeleteNLBServerGroup/2020-04-01/clb/get/text_plain/r"   DeleteNLBServerGroupResponseTr$   r*   r5   s                  r   r   z-CLBApi.delete_nlb_server_group_with_http_info  rF   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_rules  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_rules(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteRulesRequest body: (required)
        :return: DeleteRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   delete_rules_with_http_infor   s       r   delete_ruleszCLBApi.delete_rules<	  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  delete_rules  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_rules_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteRulesRequest body: (required)
        :return: DeleteRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z>Got an unexpected keyword argument '%s' to method delete_rulesNzAMissing the required parameter `body` when calling `delete_rules`r   r   r   r    r!   z+/DeleteRules/2020-04-01/clb/get/text_plain/r"   DeleteRulesResponseTr$   r*   r5   s                  r   r   z"CLBApi.delete_rules_with_http_infoQ	  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_server_group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_server_group(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteServerGroupRequest body: (required)
        :return: DeleteServerGroupResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "delete_server_group_with_http_infor   s       r   delete_server_groupzCLBApi.delete_server_group	  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  delete_server_group  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.delete_server_group_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteServerGroupRequest body: (required)
        :return: DeleteServerGroupResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zEGot an unexpected keyword argument '%s' to method delete_server_groupNzHMissing the required parameter `body` when calling `delete_server_group`r   r   r   r    r!   z1/DeleteServerGroup/2020-04-01/clb/get/text_plain/r"   DeleteServerGroupResponseTr$   r*   r5   s                  r   r   z)CLBApi.delete_server_group_with_http_info	  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_acl_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_acl_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeAclAttributesRequest body: (required)
        :return: DescribeAclAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &describe_acl_attributes_with_http_infor   s       r   describe_acl_attributeszCLBApi.describe_acl_attributes	  rC   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a"  describe_acl_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_acl_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeAclAttributesRequest body: (required)
        :return: DescribeAclAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method describe_acl_attributesNzLMissing the required parameter `body` when calling `describe_acl_attributes`r   r   r   r    r!   z5/DescribeAclAttributes/2020-04-01/clb/get/text_plain/r"   DescribeAclAttributesResponseTr$   r*   r5   s                  r   r   z-CLBApi.describe_acl_attributes_with_http_info
       X
+&&&2333,---,---fX&677 	 	HC*$$9;>?   F3KK8?1 	mvV7K7K7=f~7MklllV .K"&/"F"F #" #"h )-(R(RN) )n% **''CU#!9'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_acls  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_acls(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeAclsRequest body: (required)
        :return: DescribeAclsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   describe_acls_with_http_infor   s       r   describe_aclszCLBApi.describe_acls_
  ]     ,0'(::k"" 	444TDDVDDD6T6tFFvFFTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  describe_acls  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_acls_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeAclsRequest body: (required)
        :return: DescribeAclsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z?Got an unexpected keyword argument '%s' to method describe_aclsNzBMissing the required parameter `body` when calling `describe_acls`r   r   r   r    r!   z,/DescribeAcls/2020-04-01/clb/get/text_plain/r"   DescribeAclsResponseTr$   r*   r5   s                  r   r   z#CLBApi.describe_acls_with_http_infot
       X
+&&&2333,---,---fX&677 	 	HC*$$/145   F3KK8?1 	cvV7K7K7=f~7MabbbV .K"&/"F"F #" #"h )-(R(RN) )n% **'':E#!0'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_certificates  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_certificates(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeCertificatesRequest body: (required)
        :return: DescribeCertificatesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $describe_certificates_with_http_infor   s       r   describe_certificateszCLBApi.describe_certificates
  ]     ,0'(::k"" 	<4<TLLVLLL>T>tNNvNNTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  describe_certificates  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_certificates_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeCertificatesRequest body: (required)
        :return: DescribeCertificatesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method describe_certificatesNzJMissing the required parameter `body` when calling `describe_certificates`r   r   r   r    r!   z4/DescribeCertificates/2020-04-01/clb/get/text_plain/r"   DescribeCertificatesResponseTr$   r*   r5   s                  r   r   z+CLBApi.describe_certificates_with_http_info
  s     X
+&&&2333,---,---fX&677 	 	HC*$$79<=   F3KK8?1 	kvV7K7K7=f~7MijjjV .K"&/"F"F #" #"h )-(R(RN) )n% **''BE#!8'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )aa  describe_health_check_log_project_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_health_check_log_project_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeHealthCheckLogProjectAttributesRequest body: (required)
        :return: DescribeHealthCheckLogProjectAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   ;describe_health_check_log_project_attributes_with_http_infor   s       r   ,describe_health_check_log_project_attributesz3CLBApi.describe_health_check_log_project_attributes!  a     ,0'(::k"" 	S4STXcc\bcccUTUVZee^deeTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )ap  describe_health_check_log_project_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_health_check_log_project_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeHealthCheckLogProjectAttributesRequest body: (required)
        :return: DescribeHealthCheckLogProjectAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z^Got an unexpected keyword argument '%s' to method describe_health_check_log_project_attributesNzaMissing the required parameter `body` when calling `describe_health_check_log_project_attributes`r   r   r   r    r!   zG/DescribeHealthCheckLogProjectAttributes/2020-04-01/clb/get/text_plain/r"   /DescribeHealthCheckLogProjectAttributesResponseTr$   r*   r5   s                  r   r   zBCLBApi.describe_health_check_log_project_attributes_with_http_info6      X
+&&&2333,---,---fX&677 	 	HC*$$NPST   F3KK8?1 	BvV7K7K7=f~7M  A  B  B  BV .K"&/"F"F #" #"h )-(R(RN) )n% **''UW\#!K'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )aY  describe_health_check_log_topic_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_health_check_log_topic_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeHealthCheckLogTopicAttributesRequest body: (required)
        :return: DescribeHealthCheckLogTopicAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   9describe_health_check_log_topic_attributes_with_http_infor   s       r   *describe_health_check_log_topic_attributesz1CLBApi.describe_health_check_log_topic_attributes  sa     ,0'(::k"" 	Q4QRVaaZ`aaaSTSTXcc\bccTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )ah  describe_health_check_log_topic_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_health_check_log_topic_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeHealthCheckLogTopicAttributesRequest body: (required)
        :return: DescribeHealthCheckLogTopicAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z\Got an unexpected keyword argument '%s' to method describe_health_check_log_topic_attributesNz_Missing the required parameter `body` when calling `describe_health_check_log_topic_attributes`r   r   r   r    r!   zE/DescribeHealthCheckLogTopicAttributes/2020-04-01/clb/get/text_plain/r"   -DescribeHealthCheckLogTopicAttributesResponseTr$   r*   r5   s                  r   r   z@CLBApi.describe_health_check_log_topic_attributes_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$LNQR   F3KK8?1 	@vV7K7K7=f~7M~V .K"&/"F"F #" #"h )-(R(RN) )n% **''SUZ#!I'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a'  describe_listener_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_listener_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeListenerAttributesRequest body: (required)
        :return: DescribeListenerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   +describe_listener_attributes_with_http_infor   s       r   describe_listener_attributesz#CLBApi.describe_listener_attributes  ry   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a6  describe_listener_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_listener_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeListenerAttributesRequest body: (required)
        :return: DescribeListenerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zNGot an unexpected keyword argument '%s' to method describe_listener_attributesNzQMissing the required parameter `body` when calling `describe_listener_attributes`r   r   r   r    r!   z:/DescribeListenerAttributes/2020-04-01/clb/get/text_plain/r"   "DescribeListenerAttributesResponseTr$   r*   r5   s                  r   r   z2CLBApi.describe_listener_attributes_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$>@CD   F3KK8?1 	rvV7K7K7=f~7MpqqqV .K"&/"F"F #" #"h )-(R(RN) )n% **''H%#!>'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_listener_health  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_listener_health(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeListenerHealthRequest body: (required)
        :return: DescribeListenerHealthResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'describe_listener_health_with_http_infor   s       r   describe_listener_healthzCLBApi.describe_listener_healthD  s]     ,0'(::k"" 	?4?OOOOOATA$QQ&QQTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a&  describe_listener_health  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_listener_health_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeListenerHealthRequest body: (required)
        :return: DescribeListenerHealthResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zJGot an unexpected keyword argument '%s' to method describe_listener_healthNzMMissing the required parameter `body` when calling `describe_listener_health`r   r   r   r    r!   z6/DescribeListenerHealth/2020-04-01/clb/get/text_plain/r"   DescribeListenerHealthResponseTr$   r*   r5   s                  r   r   z.CLBApi.describe_listener_health_with_http_infoY  s    X
+&&&2333,---,---fX&677 	 	HC*$$:<?@   F3KK8?1 	nvV7K7K7=f~7MlmmmV .K"&/"F"F #" #"h )-(R(RN) )n% **''De#!:'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_listeners  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_listeners(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeListenersRequest body: (required)
        :return: DescribeListenersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !describe_listeners_with_http_infor   s       r   describe_listenerszCLBApi.describe_listeners  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  describe_listeners  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_listeners_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeListenersRequest body: (required)
        :return: DescribeListenersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method describe_listenersNzGMissing the required parameter `body` when calling `describe_listeners`r   r   r   r    r!   z1/DescribeListeners/2020-04-01/clb/get/text_plain/r"   DescribeListenersResponseTr$   r*   r5   s                  r   r   z(CLBApi.describe_listeners_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a9  describe_load_balancer_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_load_balancer_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeLoadBalancerAttributesRequest body: (required)
        :return: DescribeLoadBalancerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   0describe_load_balancer_attributes_with_http_infor   s       r   !describe_load_balancer_attributesz(CLBApi.describe_load_balancer_attributes  _     ,0'(::k"" 	H4HXXQWXXXJTJ4ZZSYZZTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aH  describe_load_balancer_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_load_balancer_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeLoadBalancerAttributesRequest body: (required)
        :return: DescribeLoadBalancerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zSGot an unexpected keyword argument '%s' to method describe_load_balancer_attributesNzVMissing the required parameter `body` when calling `describe_load_balancer_attributes`r   r   r   r    r!   z>/DescribeLoadBalancerAttributes/2020-04-01/clb/get/text_plain/r"   &DescribeLoadBalancerAttributesResponseTr$   r*   r5   s                  r   r  z7CLBApi.describe_load_balancer_attributes_with_http_info      X
+&&&2333,---,---fX&677 	 	HC*$$CEHI   F3KK8?1 	wvV7K7K7=f~7MuvvvV .K"&/"F"F #" #"h )-(R(RN) )n% **''Le#!B'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a%  describe_load_balancer_specs  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_load_balancer_specs(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeLoadBalancerSpecsRequest body: (required)
        :return: DescribeLoadBalancerSpecsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   +describe_load_balancer_specs_with_http_infor   s       r   describe_load_balancer_specsz#CLBApi.describe_load_balancer_specsg  ry   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a4  describe_load_balancer_specs  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_load_balancer_specs_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeLoadBalancerSpecsRequest body: (required)
        :return: DescribeLoadBalancerSpecsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zNGot an unexpected keyword argument '%s' to method describe_load_balancer_specsNzQMissing the required parameter `body` when calling `describe_load_balancer_specs`r   r   r   r    r!   z9/DescribeLoadBalancerSpecs/2020-04-01/clb/get/text_plain/r"   !DescribeLoadBalancerSpecsResponseTr$   r*   r5   s                  r   r  z2CLBApi.describe_load_balancer_specs_with_http_info|  r|   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a)  describe_load_balancer_status  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_load_balancer_status(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeLoadBalancerStatusRequest body: (required)
        :return: DescribeLoadBalancerStatusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   ,describe_load_balancer_status_with_http_infor   s       r   describe_load_balancer_statusz$CLBApi.describe_load_balancer_status  rP   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a8  describe_load_balancer_status  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_load_balancer_status_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeLoadBalancerStatusRequest body: (required)
        :return: DescribeLoadBalancerStatusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zOGot an unexpected keyword argument '%s' to method describe_load_balancer_statusNzRMissing the required parameter `body` when calling `describe_load_balancer_status`r   r   r   r    r!   z:/DescribeLoadBalancerStatus/2020-04-01/clb/get/text_plain/r"   "DescribeLoadBalancerStatusResponseTr$   r*   r5   s                  r   r  z3CLBApi.describe_load_balancer_status_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$?ADE   F3KK8?1 	svV7K7K7=f~7MqrrrV .K"&/"F"F #" #"h )-(R(RN) )n% **''H%#!>'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_load_balancers  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_load_balancers(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeLoadBalancersRequest body: (required)
        :return: DescribeLoadBalancersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &describe_load_balancers_with_http_infor   s       r   describe_load_balancerszCLBApi.describe_load_balancers)  rC   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a"  describe_load_balancers  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_load_balancers_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeLoadBalancersRequest body: (required)
        :return: DescribeLoadBalancersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method describe_load_balancersNzLMissing the required parameter `body` when calling `describe_load_balancers`r   r   r   r    r!   z5/DescribeLoadBalancers/2020-04-01/clb/get/text_plain/r"   DescribeLoadBalancersResponseTr$   r*   r5   s                  r   r  z-CLBApi.describe_load_balancers_with_http_info>  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a1  describe_load_balancers_billing  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_load_balancers_billing(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeLoadBalancersBillingRequest body: (required)
        :return: DescribeLoadBalancersBillingResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   .describe_load_balancers_billing_with_http_infor   s       r   describe_load_balancers_billingz&CLBApi.describe_load_balancers_billing  re   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a@  describe_load_balancers_billing  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_load_balancers_billing_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeLoadBalancersBillingRequest body: (required)
        :return: DescribeLoadBalancersBillingResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zQGot an unexpected keyword argument '%s' to method describe_load_balancers_billingNzTMissing the required parameter `body` when calling `describe_load_balancers_billing`r   r   r   r    r!   z</DescribeLoadBalancersBilling/2020-04-01/clb/get/text_plain/r"   $DescribeLoadBalancersBillingResponseTr$   r*   r5   s                  r   r  z5CLBApi.describe_load_balancers_billing_with_http_info      X
+&&&2333,---,---fX&677 	 	HC*$$ACFG   F3KK8?1 	uvV7K7K7=f~7MstttV .K"&/"F"F #" #"h )-(R(RN) )n% **''JE#!@'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )aW  describe_network_load_balancer_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_network_load_balancer_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNetworkLoadBalancerAttributesRequest body: (required)
        :return: DescribeNetworkLoadBalancerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   8describe_network_load_balancer_attributes_with_http_infor   s       r   )describe_network_load_balancer_attributesz0CLBApi.describe_network_load_balancer_attributes  a     ,0'(::k"" 	P4PQU``Y_```RTRSWbb[abbTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )af  describe_network_load_balancer_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_network_load_balancer_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNetworkLoadBalancerAttributesRequest body: (required)
        :return: DescribeNetworkLoadBalancerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z[Got an unexpected keyword argument '%s' to method describe_network_load_balancer_attributesNz^Missing the required parameter `body` when calling `describe_network_load_balancer_attributes`r   r   r   r    r!   zE/DescribeNetworkLoadBalancerAttributes/2020-04-01/clb/get/text_plain/r"   -DescribeNetworkLoadBalancerAttributesResponseTr$   r*   r5   s                  r   r   z?CLBApi.describe_network_load_balancer_attributes_with_http_info   s    X
+&&&2333,---,---fX&677 	 	HC*$$KMPQ   F3KK8?1 	vV7K7K7=f~7M}~~~V .K"&/"F"F #" #"h )-(R(RN) )n% **''SUZ#!I'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a1  describe_network_load_balancers  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_network_load_balancers(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNetworkLoadBalancersRequest body: (required)
        :return: DescribeNetworkLoadBalancersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   .describe_network_load_balancers_with_http_infor   s       r   describe_network_load_balancersz&CLBApi.describe_network_load_balancersL  re   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a@  describe_network_load_balancers  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_network_load_balancers_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNetworkLoadBalancersRequest body: (required)
        :return: DescribeNetworkLoadBalancersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zQGot an unexpected keyword argument '%s' to method describe_network_load_balancersNzTMissing the required parameter `body` when calling `describe_network_load_balancers`r   r   r   r    r!   z</DescribeNetworkLoadBalancers/2020-04-01/clb/get/text_plain/r"   $DescribeNetworkLoadBalancersResponseTr$   r*   r5   s                  r   r&  z5CLBApi.describe_network_load_balancers_with_http_infoa  r  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a5  describe_nlb_listener_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_listener_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBListenerAttributesRequest body: (required)
        :return: DescribeNLBListenerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   /describe_nlb_listener_attributes_with_http_infor   s       r    describe_nlb_listener_attributesz'CLBApi.describe_nlb_listener_attributes  rJ   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aD  describe_nlb_listener_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_listener_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBListenerAttributesRequest body: (required)
        :return: DescribeNLBListenerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zRGot an unexpected keyword argument '%s' to method describe_nlb_listener_attributesNzUMissing the required parameter `body` when calling `describe_nlb_listener_attributes`r   r   r   r    r!   z=/DescribeNLBListenerAttributes/2020-04-01/clb/get/text_plain/r"   %DescribeNLBListenerAttributesResponseTr$   r*   r5   s                  r   r+  z6CLBApi.describe_nlb_listener_attributes_with_http_info      X
+&&&2333,---,---fX&677 	 	HC*$$BDGH   F3KK8?1 	vvV7K7K7=f~7MtuuuV .K"&/"F"F #" #"h )-(R(RN) )n% **''KU#!A'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a=  describe_nlb_listener_certificates  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_listener_certificates(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBListenerCertificatesRequest body: (required)
        :return: DescribeNLBListenerCertificatesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   1describe_nlb_listener_certificates_with_http_infor   s       r   "describe_nlb_listener_certificatesz)CLBApi.describe_nlb_listener_certificates  rW   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aL  describe_nlb_listener_certificates  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_listener_certificates_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBListenerCertificatesRequest body: (required)
        :return: DescribeNLBListenerCertificatesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zTGot an unexpected keyword argument '%s' to method describe_nlb_listener_certificatesNzWMissing the required parameter `body` when calling `describe_nlb_listener_certificates`r   r   r   r    r!   z?/DescribeNLBListenerCertificates/2020-04-01/clb/get/text_plain/r"   'DescribeNLBListenerCertificatesResponseTr$   r*   r5   s                  r   r1  z8CLBApi.describe_nlb_listener_certificates_with_http_info#  s    X
+&&&2333,---,---fX&677 	 	HC*$$DFIJ   F3KK8?1 	xvV7K7K7=f~7MvwwwV .K"&/"F"F #" #"h )-(R(RN) )n% **''Mu#!C'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a%  describe_nlb_listener_health  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_listener_health(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBListenerHealthRequest body: (required)
        :return: DescribeNLBListenerHealthResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   +describe_nlb_listener_health_with_http_infor   s       r   describe_nlb_listener_healthz#CLBApi.describe_nlb_listener_healtho  ry   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a4  describe_nlb_listener_health  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_listener_health_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBListenerHealthRequest body: (required)
        :return: DescribeNLBListenerHealthResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zNGot an unexpected keyword argument '%s' to method describe_nlb_listener_healthNzQMissing the required parameter `body` when calling `describe_nlb_listener_health`r   r   r   r    r!   z9/DescribeNLBListenerHealth/2020-04-01/clb/get/text_plain/r"   !DescribeNLBListenerHealthResponseTr$   r*   r5   s                  r   r6  z2CLBApi.describe_nlb_listener_health_with_http_info  r|   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_nlb_listeners  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_listeners(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBListenersRequest body: (required)
        :return: DescribeNLBListenersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   %describe_nlb_listeners_with_http_infor   s       r   describe_nlb_listenerszCLBApi.describe_nlb_listeners  ]     ,0'(::k"" 	=4=dMMfMMM?T?OOOOTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  describe_nlb_listeners  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_listeners_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBListenersRequest body: (required)
        :return: DescribeNLBListenersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method describe_nlb_listenersNzKMissing the required parameter `body` when calling `describe_nlb_listeners`r   r   r   r    r!   z4/DescribeNLBListeners/2020-04-01/clb/get/text_plain/r"   DescribeNLBListenersResponseTr$   r*   r5   s                  r   r;  z,CLBApi.describe_nlb_listeners_with_http_info       X
+&&&2333,---,---fX&677 	 	HC*$$8:=>   F3KK8?1 	lvV7K7K7=f~7MjkkkV .K"&/"F"F #" #"h )-(R(RN) )n% **''BE#!8'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a-  describe_nlb_security_policies  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_security_policies(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBSecurityPoliciesRequest body: (required)
        :return: DescribeNLBSecurityPoliciesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   -describe_nlb_security_policies_with_http_infor   s       r   describe_nlb_security_policiesz%CLBApi.describe_nlb_security_policies1  ^     ,0'(::k"" 	E4EdUUfUUUGTGWWPVWWTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a<  describe_nlb_security_policies  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_security_policies_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBSecurityPoliciesRequest body: (required)
        :return: DescribeNLBSecurityPoliciesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zPGot an unexpected keyword argument '%s' to method describe_nlb_security_policiesNzSMissing the required parameter `body` when calling `describe_nlb_security_policies`r   r   r   r    r!   z;/DescribeNLBSecurityPolicies/2020-04-01/clb/get/text_plain/r"   #DescribeNLBSecurityPoliciesResponseTr$   r*   r5   s                  r   rB  z4CLBApi.describe_nlb_security_policies_with_http_infoF      X
+&&&2333,---,---fX&677 	 	HC*$$@BEF   F3KK8?1 	tvV7K7K7=f~7MrsssV .K"&/"F"F #" #"h )-(R(RN) )n% **''I5#!?'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )aC  describe_nlb_server_group_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_server_group_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBServerGroupAttributesRequest body: (required)
        :return: DescribeNLBServerGroupAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   3describe_nlb_server_group_attributes_with_http_infor   s       r   $describe_nlb_server_group_attributesz+CLBApi.describe_nlb_server_group_attributes  s_     ,0'(::k"" 	K4KD[[TZ[[[MTMd]]V\]]TKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aR  describe_nlb_server_group_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_server_group_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBServerGroupAttributesRequest body: (required)
        :return: DescribeNLBServerGroupAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zVGot an unexpected keyword argument '%s' to method describe_nlb_server_group_attributesNzYMissing the required parameter `body` when calling `describe_nlb_server_group_attributes`r   r   r   r    r!   z@/DescribeNLBServerGroupAttributes/2020-04-01/clb/get/text_plain/r"   (DescribeNLBServerGroupAttributesResponseTr$   r*   r5   s                  r   rI  z:CLBApi.describe_nlb_server_group_attributes_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$FHKL   F3KK8?1 	zvV7K7K7=f~7MxyyyV .K"&/"F"F #" #"h )-(R(RN) )n% **''NPU#!D'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_nlb_server_groups  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_server_groups(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBServerGroupsRequest body: (required)
        :return: DescribeNLBServerGroupsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )describe_nlb_server_groups_with_http_infor   s       r   describe_nlb_server_groupsz!CLBApi.describe_nlb_server_groups  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a,  describe_nlb_server_groups  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_server_groups_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBServerGroupsRequest body: (required)
        :return: DescribeNLBServerGroupsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method describe_nlb_server_groupsNzOMissing the required parameter `body` when calling `describe_nlb_server_groups`r   r   r   r    r!   z7/DescribeNLBServerGroups/2020-04-01/clb/get/text_plain/r"   DescribeNLBServerGroupsResponseTr$   r*   r5   s                  r   rN  z0CLBApi.describe_nlb_server_groups_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )aG  describe_nlb_system_security_policies  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_system_security_policies(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBSystemSecurityPoliciesRequest body: (required)
        :return: DescribeNLBSystemSecurityPoliciesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   4describe_nlb_system_security_policies_with_http_infor   s       r   %describe_nlb_system_security_policiesz,CLBApi.describe_nlb_system_security_policiesT  _     ,0'(::k"" 	L4LT\\U[\\\NTNt^^W]^^TKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aV  describe_nlb_system_security_policies  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_system_security_policies_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBSystemSecurityPoliciesRequest body: (required)
        :return: DescribeNLBSystemSecurityPoliciesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zWGot an unexpected keyword argument '%s' to method describe_nlb_system_security_policiesNzZMissing the required parameter `body` when calling `describe_nlb_system_security_policies`r   r   r   r    r!   zA/DescribeNLBSystemSecurityPolicies/2020-04-01/clb/get/text_plain/r"   )DescribeNLBSystemSecurityPoliciesResponseTr$   r*   r5   s                  r   rS  z;CLBApi.describe_nlb_system_security_policies_with_http_infoi      X
+&&&2333,---,---fX&677 	 	HC*$$GILM   F3KK8?1 	{vV7K7K7=f~7MyzzzV .K"&/"F"F #" #"h )-(R(RN) )n% **''OQV#!E'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_nlb_zones  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_zones(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBZonesRequest body: (required)
        :return: DescribeNLBZonesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !describe_nlb_zones_with_http_infor   s       r   describe_nlb_zoneszCLBApi.describe_nlb_zones  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  describe_nlb_zones  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_nlb_zones_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeNLBZonesRequest body: (required)
        :return: DescribeNLBZonesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method describe_nlb_zonesNzGMissing the required parameter `body` when calling `describe_nlb_zones`r   r   r   r    r!   z0/DescribeNLBZones/2020-04-01/clb/get/text_plain/r"   DescribeNLBZonesResponseTr$   r*   r5   s                  r   rZ  z(CLBApi.describe_nlb_zones_with_http_info       X
+&&&2333,---,---fX&677 	 	HC*$$469:   F3KK8?1 	hvV7K7K7=f~7MfgggV .K"&/"F"F #" #"h )-(R(RN) )n% **''>#!4'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_rules  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_rules(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeRulesRequest body: (required)
        :return: DescribeRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   describe_rules_with_http_infor   s       r   describe_ruleszCLBApi.describe_rules  ]     ,0'(::k"" 	545dEEfEEE7T7GGGGTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a   describe_rules  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_rules_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeRulesRequest body: (required)
        :return: DescribeRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z@Got an unexpected keyword argument '%s' to method describe_rulesNzCMissing the required parameter `body` when calling `describe_rules`r   r   r   r    r!   z-/DescribeRules/2020-04-01/clb/get/text_plain/r"   DescribeRulesResponseTr$   r*   r5   s                  r   r`  z$CLBApi.describe_rules_with_http_info+       X
+&&&2333,---,---fX&677 	 	HC*$$0256   F3KK8?1 	dvV7K7K7=f~7MbcccV .K"&/"F"F #" #"h )-(R(RN) )n% **'';U#!1'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a5  describe_server_group_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_server_group_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeServerGroupAttributesRequest body: (required)
        :return: DescribeServerGroupAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   /describe_server_group_attributes_with_http_infor   s       r    describe_server_group_attributesz'CLBApi.describe_server_group_attributesw  rJ   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aD  describe_server_group_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_server_group_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeServerGroupAttributesRequest body: (required)
        :return: DescribeServerGroupAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zRGot an unexpected keyword argument '%s' to method describe_server_group_attributesNzUMissing the required parameter `body` when calling `describe_server_group_attributes`r   r   r   r    r!   z=/DescribeServerGroupAttributes/2020-04-01/clb/get/text_plain/r"   %DescribeServerGroupAttributesResponseTr$   r*   r5   s                  r   rg  z6CLBApi.describe_server_group_attributes_with_http_info  r/  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_server_groups  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_server_groups(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeServerGroupsRequest body: (required)
        :return: DescribeServerGroupsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   %describe_server_groups_with_http_infor   s       r   describe_server_groupszCLBApi.describe_server_groups  r=  r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  describe_server_groups  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_server_groups_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeServerGroupsRequest body: (required)
        :return: DescribeServerGroupsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method describe_server_groupsNzKMissing the required parameter `body` when calling `describe_server_groups`r   r   r   r    r!   z4/DescribeServerGroups/2020-04-01/clb/get/text_plain/r"   DescribeServerGroupsResponseTr$   r*   r5   s                  r   rl  z,CLBApi.describe_server_groups_with_http_info  r@  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_zones  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_zones(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeZonesRequest body: (required)
        :return: DescribeZonesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   describe_zones_with_http_infor   s       r   describe_zoneszCLBApi.describe_zones9  rb  r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a   describe_zones  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.describe_zones_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeZonesRequest body: (required)
        :return: DescribeZonesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z@Got an unexpected keyword argument '%s' to method describe_zonesNzCMissing the required parameter `body` when calling `describe_zones`r   r   r   r    r!   z-/DescribeZones/2020-04-01/clb/get/text_plain/r"   DescribeZonesResponseTr$   r*   r5   s                  r   rq  z$CLBApi.describe_zones_with_http_infoN  re  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a'  detach_health_check_log_topic  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.detach_health_check_log_topic(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DetachHealthCheckLogTopicRequest body: (required)
        :return: DetachHealthCheckLogTopicResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   ,detach_health_check_log_topic_with_http_infor   s       r   detach_health_check_log_topicz$CLBApi.detach_health_check_log_topic  rP   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a6  detach_health_check_log_topic  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.detach_health_check_log_topic_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DetachHealthCheckLogTopicRequest body: (required)
        :return: DetachHealthCheckLogTopicResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zOGot an unexpected keyword argument '%s' to method detach_health_check_log_topicNzRMissing the required parameter `body` when calling `detach_health_check_log_topic`r   r   r   r    r!   z9/DetachHealthCheckLogTopic/2020-04-01/clb/get/text_plain/r"   !DetachHealthCheckLogTopicResponseTr$   r*   r5   s                  r   rv  z3CLBApi.detach_health_check_log_topic_with_http_info  rS   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  disable_access_log  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_access_log(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DisableAccessLogRequest body: (required)
        :return: DisableAccessLogResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !disable_access_log_with_http_infor   s       r   disable_access_logzCLBApi.disable_access_log  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  disable_access_log  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_access_log_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DisableAccessLogRequest body: (required)
        :return: DisableAccessLogResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method disable_access_logNzGMissing the required parameter `body` when calling `disable_access_log`r   r   r   r    r!   z0/DisableAccessLog/2020-04-01/clb/get/text_plain/r"   DisableAccessLogResponseTr$   r*   r5   s                  r   r{  z(CLBApi.disable_access_log_with_http_info  r^  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  enable_access_log  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_access_log(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableAccessLogRequest body: (required)
        :return: EnableAccessLogResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r    enable_access_log_with_http_infor   s       r   enable_access_logzCLBApi.enable_access_log\  ]     ,0'(::k"" 	848HHHHH:T:4JJ6JJTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a
  enable_access_log  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_access_log_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableAccessLogRequest body: (required)
        :return: EnableAccessLogResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zCGot an unexpected keyword argument '%s' to method enable_access_logNzFMissing the required parameter `body` when calling `enable_access_log`r   r   r   r    r!   z//EnableAccessLog/2020-04-01/clb/get/text_plain/r"   EnableAccessLogResponseTr$   r*   r5   s                  r   r  z'CLBApi.enable_access_log_with_http_infoq       X
+&&&2333,---,---fX&677 	 	HC*$$3589   F3KK8?1 	gvV7K7K7=f~7MefffV .K"&/"F"F #" #"h )-(R(RN) )n% **''=u#!3'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_tags_for_nlb_resources  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_tags_for_nlb_resources(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListTagsForNLBResourcesRequest body: (required)
        :return: ListTagsForNLBResourcesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   *list_tags_for_nlb_resources_with_http_infor   s       r   list_tags_for_nlb_resourcesz"CLBApi.list_tags_for_nlb_resources  s]     ,0'(::k"" 	B4B4RR6RRRDTDTTTVTTTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a.  list_tags_for_nlb_resources  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_tags_for_nlb_resources_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListTagsForNLBResourcesRequest body: (required)
        :return: ListTagsForNLBResourcesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zMGot an unexpected keyword argument '%s' to method list_tags_for_nlb_resourcesNzPMissing the required parameter `body` when calling `list_tags_for_nlb_resources`r   r   r   r    r!   z7/ListTagsForNLBResources/2020-04-01/clb/get/text_plain/r"   ListTagsForNLBResourcesResponseTr$   r*   r5   s                  r   r  z1CLBApi.list_tags_for_nlb_resources_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$=?BC   F3KK8?1 	qvV7K7K7=f~7MopppV .K"&/"F"F #" #"h )-(R(RN) )n% **''Eu#!;'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_tags_for_resources  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_tags_for_resources(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListTagsForResourcesRequest body: (required)
        :return: ListTagsForResourcesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &list_tags_for_resources_with_http_infor   s       r   list_tags_for_resourceszCLBApi.list_tags_for_resources  rC   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a   list_tags_for_resources  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_tags_for_resources_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListTagsForResourcesRequest body: (required)
        :return: ListTagsForResourcesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method list_tags_for_resourcesNzLMissing the required parameter `body` when calling `list_tags_for_resources`r   r   r   r    r!   z4/ListTagsForResources/2020-04-01/clb/get/text_plain/r"   ListTagsForResourcesResponseTr$   r*   r5   s                  r   r  z-CLBApi.list_tags_for_resources_with_http_info3  rF   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  modify_acl_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_acl_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyAclAttributesRequest body: (required)
        :return: ModifyAclAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $modify_acl_attributes_with_http_infor   s       r   modify_acl_attributeszCLBApi.modify_acl_attributes  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  modify_acl_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_acl_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyAclAttributesRequest body: (required)
        :return: ModifyAclAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method modify_acl_attributesNzJMissing the required parameter `body` when calling `modify_acl_attributes`r   r   r   r    r!   z3/ModifyAclAttributes/2020-04-01/clb/get/text_plain/r"   ModifyAclAttributesResponseTr$   r*   r5   s                  r   r  z+CLBApi.modify_acl_attributes_with_http_info  s     X
+&&&2333,---,---fX&677 	 	HC*$$79<=   F3KK8?1 	kvV7K7K7=f~7MijjjV .K"&/"F"F #" #"h )-(R(RN) )n% **''A5#!7'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a+  modify_certificate_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_certificate_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyCertificateAttributesRequest body: (required)
        :return: ModifyCertificateAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   ,modify_certificate_attributes_with_http_infor   s       r   modify_certificate_attributesz$CLBApi.modify_certificate_attributes  rP   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a:  modify_certificate_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_certificate_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyCertificateAttributesRequest body: (required)
        :return: ModifyCertificateAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zOGot an unexpected keyword argument '%s' to method modify_certificate_attributesNzRMissing the required parameter `body` when calling `modify_certificate_attributes`r   r   r   r    r!   z;/ModifyCertificateAttributes/2020-04-01/clb/get/text_plain/r"   #ModifyCertificateAttributesResponseTr$   r*   r5   s                  r   r  z3CLBApi.modify_certificate_attributes_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$?ADE   F3KK8?1 	svV7K7K7=f~7MqrrrV .K"&/"F"F #" #"h )-(R(RN) )n% **''I5#!?'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  modify_listener_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_listener_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyListenerAttributesRequest body: (required)
        :return: ModifyListenerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )modify_listener_attributes_with_http_infor   s       r   modify_listener_attributesz!CLBApi.modify_listener_attributesA  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a.  modify_listener_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_listener_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyListenerAttributesRequest body: (required)
        :return: ModifyListenerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method modify_listener_attributesNzOMissing the required parameter `body` when calling `modify_listener_attributes`r   r   r   r    r!   z8/ModifyListenerAttributes/2020-04-01/clb/get/text_plain/r"    ModifyListenerAttributesResponseTr$   r*   r5   s                  r   r  z0CLBApi.modify_listener_attributes_with_http_infoV  s    X
+&&&2333,---,---fX&677 	 	HC*$$<>AB   F3KK8?1 	pvV7K7K7=f~7MnoooV .K"&/"F"F #" #"h )-(R(RN) )n% **''F#!<'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a9  modify_listener_domain_extensions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_listener_domain_extensions(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyListenerDomainExtensionsRequest body: (required)
        :return: ModifyListenerDomainExtensionsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   0modify_listener_domain_extensions_with_http_infor   s       r   !modify_listener_domain_extensionsz(CLBApi.modify_listener_domain_extensions  r  r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aH  modify_listener_domain_extensions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_listener_domain_extensions_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyListenerDomainExtensionsRequest body: (required)
        :return: ModifyListenerDomainExtensionsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zSGot an unexpected keyword argument '%s' to method modify_listener_domain_extensionsNzVMissing the required parameter `body` when calling `modify_listener_domain_extensions`r   r   r   r    r!   z>/ModifyListenerDomainExtensions/2020-04-01/clb/get/text_plain/r"   &ModifyListenerDomainExtensionsResponseTr$   r*   r5   s                  r   r  z7CLBApi.modify_listener_domain_extensions_with_http_info  r	  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a1  modify_load_balancer_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_load_balancer_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyLoadBalancerAttributesRequest body: (required)
        :return: ModifyLoadBalancerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   .modify_load_balancer_attributes_with_http_infor   s       r   modify_load_balancer_attributesz&CLBApi.modify_load_balancer_attributes  re   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a@  modify_load_balancer_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_load_balancer_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyLoadBalancerAttributesRequest body: (required)
        :return: ModifyLoadBalancerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zQGot an unexpected keyword argument '%s' to method modify_load_balancer_attributesNzTMissing the required parameter `body` when calling `modify_load_balancer_attributes`r   r   r   r    r!   z</ModifyLoadBalancerAttributes/2020-04-01/clb/get/text_plain/r"   $ModifyLoadBalancerAttributesResponseTr$   r*   r5   s                  r   r  z5CLBApi.modify_load_balancer_attributes_with_http_info  r  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )aM  modify_network_load_balancer_access_log  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_network_load_balancer_access_log(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNetworkLoadBalancerAccessLogRequest body: (required)
        :return: ModifyNetworkLoadBalancerAccessLogResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   6modify_network_load_balancer_access_log_with_http_infor   s       r   'modify_network_load_balancer_access_logz.CLBApi.modify_network_load_balancer_access_logd  `     ,0'(::k"" 	N4Nt^^W]^^^PTPQU``Y_``TKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a\  modify_network_load_balancer_access_log  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_network_load_balancer_access_log_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNetworkLoadBalancerAccessLogRequest body: (required)
        :return: ModifyNetworkLoadBalancerAccessLogResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zYGot an unexpected keyword argument '%s' to method modify_network_load_balancer_access_logNz\Missing the required parameter `body` when calling `modify_network_load_balancer_access_log`r   r   r   r    r!   zB/ModifyNetworkLoadBalancerAccessLog/2020-04-01/clb/get/text_plain/r"   *ModifyNetworkLoadBalancerAccessLogResponseTr$   r*   r5   s                  r   r  z=CLBApi.modify_network_load_balancer_access_log_with_http_infoy  s    X
+&&&2333,---,---fX&677 	 	HC*$$IKNO   F3KK8?1 	}vV7K7K7=f~7M{|||V .K"&/"F"F #" #"h )-(R(RN) )n% **''PRW#!F'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )aO  modify_network_load_balancer_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_network_load_balancer_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNetworkLoadBalancerAttributesRequest body: (required)
        :return: ModifyNetworkLoadBalancerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   6modify_network_load_balancer_attributes_with_http_infor   s       r   'modify_network_load_balancer_attributesz.CLBApi.modify_network_load_balancer_attributes  r  r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a^  modify_network_load_balancer_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_network_load_balancer_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNetworkLoadBalancerAttributesRequest body: (required)
        :return: ModifyNetworkLoadBalancerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zYGot an unexpected keyword argument '%s' to method modify_network_load_balancer_attributesNz\Missing the required parameter `body` when calling `modify_network_load_balancer_attributes`r   r   r   r    r!   zC/ModifyNetworkLoadBalancerAttributes/2020-04-01/clb/get/text_plain/r"   +ModifyNetworkLoadBalancerAttributesResponseTr$   r*   r5   s                  r   r  z=CLBApi.modify_network_load_balancer_attributes_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$IKNO   F3KK8?1 	}vV7K7K7=f~7M{|||V .K"&/"F"F #" #"h )-(R(RN) )n% **''QSX#!G'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )ai  modify_network_load_balancer_bandwidth_package  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_network_load_balancer_bandwidth_package(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNetworkLoadBalancerBandwidthPackageRequest body: (required)
        :return: ModifyNetworkLoadBalancerBandwidthPackageResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   =modify_network_load_balancer_bandwidth_package_with_http_infor   s       r   .modify_network_load_balancer_bandwidth_packagez5CLBApi.modify_network_load_balancer_bandwidth_package&  sa     ,0'(::k"" 	U4UVZee^deeeWTWX\gg`fggTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )ax  modify_network_load_balancer_bandwidth_package  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_network_load_balancer_bandwidth_package_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNetworkLoadBalancerBandwidthPackageRequest body: (required)
        :return: ModifyNetworkLoadBalancerBandwidthPackageResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z`Got an unexpected keyword argument '%s' to method modify_network_load_balancer_bandwidth_packageNzcMissing the required parameter `body` when calling `modify_network_load_balancer_bandwidth_package`r   r   r   r    r!   zI/ModifyNetworkLoadBalancerBandwidthPackage/2020-04-01/clb/get/text_plain/r"   1ModifyNetworkLoadBalancerBandwidthPackageResponseTr$   r*   r5   s                  r   r  zDCLBApi.modify_network_load_balancer_bandwidth_package_with_http_info;  s    X
+&&&2333,---,---fX&677 	 	HC*$$PRUV   F3KK8?1 	DvV7K7K7=f~7M  C  D  D  DV .K"&/"F"F #" #"h )-(R(RN) )n% **''WY^#!M'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )aU  modify_network_load_balancer_network_type  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_network_load_balancer_network_type(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNetworkLoadBalancerNetworkTypeRequest body: (required)
        :return: ModifyNetworkLoadBalancerNetworkTypeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   8modify_network_load_balancer_network_type_with_http_infor   s       r   )modify_network_load_balancer_network_typez0CLBApi.modify_network_load_balancer_network_type  r"  r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )ad  modify_network_load_balancer_network_type  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_network_load_balancer_network_type_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNetworkLoadBalancerNetworkTypeRequest body: (required)
        :return: ModifyNetworkLoadBalancerNetworkTypeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z[Got an unexpected keyword argument '%s' to method modify_network_load_balancer_network_typeNz^Missing the required parameter `body` when calling `modify_network_load_balancer_network_type`r   r   r   r    r!   zD/ModifyNetworkLoadBalancerNetworkType/2020-04-01/clb/get/text_plain/r"   ,ModifyNetworkLoadBalancerNetworkTypeResponseTr$   r*   r5   s                  r   r  z?CLBApi.modify_network_load_balancer_network_type_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$KMPQ   F3KK8?1 	vV7K7K7=f~7M}~~~V .K"&/"F"F #" #"h )-(R(RN) )n% **''RTY#!H'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )aa  modify_network_load_balancer_security_groups  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_network_load_balancer_security_groups(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNetworkLoadBalancerSecurityGroupsRequest body: (required)
        :return: ModifyNetworkLoadBalancerSecurityGroupsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   ;modify_network_load_balancer_security_groups_with_http_infor   s       r   ,modify_network_load_balancer_security_groupsz3CLBApi.modify_network_load_balancer_security_groups  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )ap  modify_network_load_balancer_security_groups  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_network_load_balancer_security_groups_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNetworkLoadBalancerSecurityGroupsRequest body: (required)
        :return: ModifyNetworkLoadBalancerSecurityGroupsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z^Got an unexpected keyword argument '%s' to method modify_network_load_balancer_security_groupsNzaMissing the required parameter `body` when calling `modify_network_load_balancer_security_groups`r   r   r   r    r!   zG/ModifyNetworkLoadBalancerSecurityGroups/2020-04-01/clb/get/text_plain/r"   /ModifyNetworkLoadBalancerSecurityGroupsResponseTr$   r*   r5   s                  r   r  zBCLBApi.modify_network_load_balancer_security_groups_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a;  modify_network_load_balancer_zones  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_network_load_balancer_zones(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNetworkLoadBalancerZonesRequest body: (required)
        :return: ModifyNetworkLoadBalancerZonesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   1modify_network_load_balancer_zones_with_http_infor   s       r   "modify_network_load_balancer_zonesz)CLBApi.modify_network_load_balancer_zonesI  rW   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aJ  modify_network_load_balancer_zones  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_network_load_balancer_zones_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNetworkLoadBalancerZonesRequest body: (required)
        :return: ModifyNetworkLoadBalancerZonesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zTGot an unexpected keyword argument '%s' to method modify_network_load_balancer_zonesNzWMissing the required parameter `body` when calling `modify_network_load_balancer_zones`r   r   r   r    r!   z>/ModifyNetworkLoadBalancerZones/2020-04-01/clb/get/text_plain/r"   &ModifyNetworkLoadBalancerZonesResponseTr$   r*   r5   s                  r   r  z8CLBApi.modify_network_load_balancer_zones_with_http_info^  rZ   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )aG  modify_nlb_backend_servers_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_nlb_backend_servers_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNLBBackendServersAttributesRequest body: (required)
        :return: ModifyNLBBackendServersAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   4modify_nlb_backend_servers_attributes_with_http_infor   s       r   %modify_nlb_backend_servers_attributesz,CLBApi.modify_nlb_backend_servers_attributes  rU  r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aV  modify_nlb_backend_servers_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_nlb_backend_servers_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNLBBackendServersAttributesRequest body: (required)
        :return: ModifyNLBBackendServersAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zWGot an unexpected keyword argument '%s' to method modify_nlb_backend_servers_attributesNzZMissing the required parameter `body` when calling `modify_nlb_backend_servers_attributes`r   r   r   r    r!   zA/ModifyNLBBackendServersAttributes/2020-04-01/clb/get/text_plain/r"   )ModifyNLBBackendServersAttributesResponseTr$   r*   r5   s                  r   r  z;CLBApi.modify_nlb_backend_servers_attributes_with_http_info  rX  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a_  modify_nlb_listener_additional_certificates  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_nlb_listener_additional_certificates(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNLBListenerAdditionalCertificatesRequest body: (required)
        :return: ModifyNLBListenerAdditionalCertificatesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   :modify_nlb_listener_additional_certificates_with_http_infor   s       r   +modify_nlb_listener_additional_certificatesz2CLBApi.modify_nlb_listener_additional_certificates  sa     ,0'(::k"" 	R4RSWbb[abbbTTTUYdd]cddTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )an  modify_nlb_listener_additional_certificates  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_nlb_listener_additional_certificates_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNLBListenerAdditionalCertificatesRequest body: (required)
        :return: ModifyNLBListenerAdditionalCertificatesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z]Got an unexpected keyword argument '%s' to method modify_nlb_listener_additional_certificatesNz`Missing the required parameter `body` when calling `modify_nlb_listener_additional_certificates`r   r   r   r    r!   zG/ModifyNLBListenerAdditionalCertificates/2020-04-01/clb/get/text_plain/r"   /ModifyNLBListenerAdditionalCertificatesResponseTr$   r*   r5   s                  r   r  zACLBApi.modify_nlb_listener_additional_certificates_with_http_info   s    X
+&&&2333,---,---fX&677 	 	HC*$$MORS   F3KK8?1 	AvV7K7K7=f~7M  A  A  AV .K"&/"F"F #" #"h )-(R(RN) )n% **''UW\#!K'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a-  modify_nlb_listener_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_nlb_listener_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNLBListenerAttributesRequest body: (required)
        :return: ModifyNLBListenerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   -modify_nlb_listener_attributes_with_http_infor   s       r   modify_nlb_listener_attributesz%CLBApi.modify_nlb_listener_attributesl  rD  r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a<  modify_nlb_listener_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_nlb_listener_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNLBListenerAttributesRequest body: (required)
        :return: ModifyNLBListenerAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zPGot an unexpected keyword argument '%s' to method modify_nlb_listener_attributesNzSMissing the required parameter `body` when calling `modify_nlb_listener_attributes`r   r   r   r    r!   z;/ModifyNLBListenerAttributes/2020-04-01/clb/get/text_plain/r"   #ModifyNLBListenerAttributesResponseTr$   r*   r5   s                  r   r  z4CLBApi.modify_nlb_listener_attributes_with_http_info  rG  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )aG  modify_nlb_security_policy_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_nlb_security_policy_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNLBSecurityPolicyAttributesRequest body: (required)
        :return: ModifyNLBSecurityPolicyAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   4modify_nlb_security_policy_attributes_with_http_infor   s       r   %modify_nlb_security_policy_attributesz,CLBApi.modify_nlb_security_policy_attributes  rU  r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aV  modify_nlb_security_policy_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_nlb_security_policy_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNLBSecurityPolicyAttributesRequest body: (required)
        :return: ModifyNLBSecurityPolicyAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zWGot an unexpected keyword argument '%s' to method modify_nlb_security_policy_attributesNzZMissing the required parameter `body` when calling `modify_nlb_security_policy_attributes`r   r   r   r    r!   zA/ModifyNLBSecurityPolicyAttributes/2020-04-01/clb/get/text_plain/r"   )ModifyNLBSecurityPolicyAttributesResponseTr$   r*   r5   s                  r   r  z;CLBApi.modify_nlb_security_policy_attributes_with_http_info  rX  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a;  modify_nlb_server_group_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_nlb_server_group_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNLBServerGroupAttributesRequest body: (required)
        :return: ModifyNLBServerGroupAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   1modify_nlb_server_group_attributes_with_http_infor   s       r   "modify_nlb_server_group_attributesz)CLBApi.modify_nlb_server_group_attributes.  rW   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aJ  modify_nlb_server_group_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_nlb_server_group_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyNLBServerGroupAttributesRequest body: (required)
        :return: ModifyNLBServerGroupAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zTGot an unexpected keyword argument '%s' to method modify_nlb_server_group_attributesNzWMissing the required parameter `body` when calling `modify_nlb_server_group_attributes`r   r   r   r    r!   z>/ModifyNLBServerGroupAttributes/2020-04-01/clb/get/text_plain/r"   &ModifyNLBServerGroupAttributesResponseTr$   r*   r5   s                  r   r  z8CLBApi.modify_nlb_server_group_attributes_with_http_infoC  rZ   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  modify_rules  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_rules(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyRulesRequest body: (required)
        :return: ModifyRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   modify_rules_with_http_infor   s       r   modify_ruleszCLBApi.modify_rules  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  modify_rules  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_rules_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyRulesRequest body: (required)
        :return: ModifyRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z>Got an unexpected keyword argument '%s' to method modify_rulesNzAMissing the required parameter `body` when calling `modify_rules`r   r   r   r    r!   z+/ModifyRules/2020-04-01/clb/get/text_plain/r"   ModifyRulesResponseTr$   r*   r5   s                  r   r  z"CLBApi.modify_rules_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a-  modify_server_group_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_server_group_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyServerGroupAttributesRequest body: (required)
        :return: ModifyServerGroupAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   -modify_server_group_attributes_with_http_infor   s       r   modify_server_group_attributesz%CLBApi.modify_server_group_attributes  rD  r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a<  modify_server_group_attributes  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.modify_server_group_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyServerGroupAttributesRequest body: (required)
        :return: ModifyServerGroupAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zPGot an unexpected keyword argument '%s' to method modify_server_group_attributesNzSMissing the required parameter `body` when calling `modify_server_group_attributes`r   r   r   r    r!   z;/ModifyServerGroupAttributes/2020-04-01/clb/get/text_plain/r"   #ModifyServerGroupAttributesResponseTr$   r*   r5   s                  r   r  z4CLBApi.modify_server_group_attributes_with_http_info  rG  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  remove_acl_entries  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_acl_entries(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param RemoveAclEntriesRequest body: (required)
        :return: RemoveAclEntriesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !remove_acl_entries_with_http_infor   s       r   remove_acl_entrieszCLBApi.remove_acl_entriesQ  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  remove_acl_entries  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_acl_entries_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param RemoveAclEntriesRequest body: (required)
        :return: RemoveAclEntriesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method remove_acl_entriesNzGMissing the required parameter `body` when calling `remove_acl_entries`r   r   r   r    r!   z0/RemoveAclEntries/2020-04-01/clb/get/text_plain/r"   RemoveAclEntriesResponseTr$   r*   r5   s                  r   r  z(CLBApi.remove_acl_entries_with_http_infof  r^  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  remove_nlb_backend_servers  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_nlb_backend_servers(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param RemoveNLBBackendServersRequest body: (required)
        :return: RemoveNLBBackendServersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )remove_nlb_backend_servers_with_http_infor   s       r   remove_nlb_backend_serversz!CLBApi.remove_nlb_backend_servers  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a,  remove_nlb_backend_servers  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_nlb_backend_servers_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param RemoveNLBBackendServersRequest body: (required)
        :return: RemoveNLBBackendServersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method remove_nlb_backend_serversNzOMissing the required parameter `body` when calling `remove_nlb_backend_servers`r   r   r   r    r!   z7/RemoveNLBBackendServers/2020-04-01/clb/get/text_plain/r"   RemoveNLBBackendServersResponseTr$   r*   r5   s                  r   r  z0CLBApi.remove_nlb_backend_servers_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a?  remove_server_group_backend_servers  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_server_group_backend_servers(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param RemoveServerGroupBackendServersRequest body: (required)
        :return: RemoveServerGroupBackendServersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   2remove_server_group_backend_servers_with_http_infor   s       r   #remove_server_group_backend_serversz*CLBApi.remove_server_group_backend_servers  s_     ,0'(::k"" 	J4J4ZZSYZZZLTLT\\U[\\TKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aN  remove_server_group_backend_servers  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_server_group_backend_servers_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param RemoveServerGroupBackendServersRequest body: (required)
        :return: RemoveServerGroupBackendServersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zUGot an unexpected keyword argument '%s' to method remove_server_group_backend_serversNzXMissing the required parameter `body` when calling `remove_server_group_backend_servers`r   r   r   r    r!   z?/RemoveServerGroupBackendServers/2020-04-01/clb/get/text_plain/r"   'RemoveServerGroupBackendServersResponseTr$   r*   r5   s                  r   r  z9CLBApi.remove_server_group_backend_servers_with_http_info(  s    X
+&&&2333,---,---fX&677 	 	HC*$$EGJK   F3KK8?1 	yvV7K7K7=f~7MwxxxV .K"&/"F"F #" #"h )-(R(RN) )n% **''Mu#!C'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  renew_load_balancer  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.renew_load_balancer(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param RenewLoadBalancerRequest body: (required)
        :return: RenewLoadBalancerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "renew_load_balancer_with_http_infor   s       r   renew_load_balancerzCLBApi.renew_load_balancert  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  renew_load_balancer  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.renew_load_balancer_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param RenewLoadBalancerRequest body: (required)
        :return: RenewLoadBalancerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zEGot an unexpected keyword argument '%s' to method renew_load_balancerNzHMissing the required parameter `body` when calling `renew_load_balancer`r   r   r   r    r!   z1/RenewLoadBalancer/2020-04-01/clb/get/text_plain/r"   RenewLoadBalancerResponseTr$   r*   r5   s                  r   r  z)CLBApi.renew_load_balancer_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  set_load_balancer_renewal  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_load_balancer_renewal(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetLoadBalancerRenewalRequest body: (required)
        :return: SetLoadBalancerRenewalResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   (set_load_balancer_renewal_with_http_infor   s       r   set_load_balancer_renewalz CLBApi.set_load_balancer_renewal  s]     ,0'(::k"" 	@4@PPPPPBTB4RR6RRTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a(  set_load_balancer_renewal  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_load_balancer_renewal_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetLoadBalancerRenewalRequest body: (required)
        :return: SetLoadBalancerRenewalResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zKGot an unexpected keyword argument '%s' to method set_load_balancer_renewalNzNMissing the required parameter `body` when calling `set_load_balancer_renewal`r   r   r   r    r!   z6/SetLoadBalancerRenewal/2020-04-01/clb/get/text_plain/r"   SetLoadBalancerRenewalResponseTr$   r*   r5   s                  r   r   z/CLBApi.set_load_balancer_renewal_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$;=@A   F3KK8?1 	ovV7K7K7=f~7MmnnnV .K"&/"F"F #" #"h )-(R(RN) )n% **''De#!:'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  tag_nlb_resources  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.tag_nlb_resources(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TagNLBResourcesRequest body: (required)
        :return: TagNLBResourcesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r    tag_nlb_resources_with_http_infor   s       r   tag_nlb_resourceszCLBApi.tag_nlb_resources6  r  r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a
  tag_nlb_resources  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.tag_nlb_resources_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TagNLBResourcesRequest body: (required)
        :return: TagNLBResourcesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zCGot an unexpected keyword argument '%s' to method tag_nlb_resourcesNzFMissing the required parameter `body` when calling `tag_nlb_resources`r   r   r   r    r!   z//TagNLBResources/2020-04-01/clb/get/text_plain/r"   TagNLBResourcesResponseTr$   r*   r5   s                  r   r  z'CLBApi.tag_nlb_resources_with_http_infoK  r  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  tag_resources  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.tag_resources(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TagResourcesRequest body: (required)
        :return: TagResourcesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   tag_resources_with_http_infor   s       r   tag_resourceszCLBApi.tag_resources  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  tag_resources  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.tag_resources_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TagResourcesRequest body: (required)
        :return: TagResourcesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z?Got an unexpected keyword argument '%s' to method tag_resourcesNzBMissing the required parameter `body` when calling `tag_resources`r   r   r   r    r!   z,/TagResources/2020-04-01/clb/get/text_plain/r"   TagResourcesResponseTr$   r*   r5   s                  r   r
  z#CLBApi.tag_resources_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  untag_nlb_resources  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.untag_nlb_resources(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param UntagNLBResourcesRequest body: (required)
        :return: UntagNLBResourcesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "untag_nlb_resources_with_http_infor   s       r   untag_nlb_resourceszCLBApi.untag_nlb_resources  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  untag_nlb_resources  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.untag_nlb_resources_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param UntagNLBResourcesRequest body: (required)
        :return: UntagNLBResourcesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zEGot an unexpected keyword argument '%s' to method untag_nlb_resourcesNzHMissing the required parameter `body` when calling `untag_nlb_resources`r   r   r   r    r!   z1/UntagNLBResources/2020-04-01/clb/get/text_plain/r"   UntagNLBResourcesResponseTr$   r*   r5   s                  r   r  z)CLBApi.untag_nlb_resources_with_http_info   r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  untag_resources  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.untag_resources(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param UntagResourcesRequest body: (required)
        :return: UntagResourcesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   untag_resources_with_http_infor   s       r   untag_resourceszCLBApi.untag_resourcesY   r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  untag_resources  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.untag_resources_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param UntagResourcesRequest body: (required)
        :return: UntagResourcesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zAGot an unexpected keyword argument '%s' to method untag_resourcesNzDMissing the required parameter `body` when calling `untag_resources`r   r   r   r    r!   z./UntagResources/2020-04-01/clb/get/text_plain/r"   UntagResourcesResponseTr$   r*   r5   s                  r   r  z%CLBApi.untag_resources_with_http_infon   rn   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  upload_certificate  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upload_certificate(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param UploadCertificateRequest body: (required)
        :return: UploadCertificateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !upload_certificate_with_http_infor   s       r   upload_certificatezCLBApi.upload_certificate   r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    dg          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  upload_certificate  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upload_certificate_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param UploadCertificateRequest body: (required)
        :return: UploadCertificateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method upload_certificateNzGMissing the required parameter `body` when calling `upload_certificate`r   r   r   r    r!   z1/UploadCertificate/2020-04-01/clb/get/text_plain/r"   UploadCertificateResponseTr$   r*   r5   s                  r   r  z(CLBApi.upload_certificate_with_http_info   r   r   r   )__name__
__module____qualname____doc__r   r   r   rB   rA   rI   rH   rO   rN   rV   rU   r]   r\   rd   rc   rk   rj   rq   rp   rx   rw   r   r~   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r  r  r  r  r  r  r!  r   r'  r&  r,  r+  r2  r1  r7  r6  r<  r;  rC  rB  rJ  rI  rO  rN  rT  rS  r[  rZ  ra  r`  rh  rg  rm  rl  rr  rq  rw  rv  r|  r{  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r  r  r  r
  r  r  r  r  r  r   r   r   r   r      s        % % % %
  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3 J3 J3r   r   )r   
__future__r   rer-   r   objectr   r!  r   r   <module>r%     s     ' & & & & & 				 


    AD3 AD3 AD3 AD3 AD3V AD3 AD3 AD3 AD3 AD3r   