
    ~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
    alb

    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S )ALBApizNOTE: 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/volcenginesdkalb/api/alb_api.py__init__zALBApi.__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ALBApi.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/alb/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%ALBApi.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 )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'ALBApi.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/alb/get/text_plain/r"   $AddServerGroupBackendServersResponseTr$   r*   r5   s                  r   rA   z6ALBApi.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  clone_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.clone_load_balancer(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CloneLoadBalancerRequest body: (required)
        :return: CloneLoadBalancerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "clone_load_balancer_with_http_infor   s       r   clone_load_balancerzALBApi.clone_load_balancer   ]     ,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  clone_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.clone_load_balancer_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CloneLoadBalancerRequest body: (required)
        :return: CloneLoadBalancerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zEGot an unexpected keyword argument '%s' to method clone_load_balancerNzHMissing the required parameter `body` when calling `clone_load_balancer`r   r   r   r    r!   z1/CloneLoadBalancer/2020-04-01/alb/get/text_plain/r"   CloneLoadBalancerResponseTr$   r*   r5   s                  r   rG   z)ALBApi.clone_load_balancer_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_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ALBApi.create_aclG  ]     ,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/alb/get/text_plain/r"   CreateAclResponseTr$   r*   r5   s                  r   rN   z ALBApi.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_customized_cfg  # 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_customized_cfg(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateCustomizedCfgRequest body: (required)
        :return: CreateCustomizedCfgResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $create_customized_cfg_with_http_infor   s       r   create_customized_cfgzALBApi.create_customized_cfg  ]     ,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  create_customized_cfg  # 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_customized_cfg_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateCustomizedCfgRequest body: (required)
        :return: CreateCustomizedCfgResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method create_customized_cfgNzJMissing the required parameter `body` when calling `create_customized_cfg`r   r   r   r    r!   z3/CreateCustomizedCfg/2020-04-01/alb/get/text_plain/r"   CreateCustomizedCfgResponseTr$   r*   r5   s                  r   rU   z+ALBApi.create_customized_cfg_with_http_info       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)  create_health_check_templates  # 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_templates(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateHealthCheckTemplatesRequest body: (required)
        :return: CreateHealthCheckTemplatesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   ,create_health_check_templates_with_http_infor   s       r   create_health_check_templatesz$ALBApi.create_health_check_templates	  ]     ,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 )a8  create_health_check_templates  # 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_templates_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateHealthCheckTemplatesRequest body: (required)
        :return: CreateHealthCheckTemplatesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zOGot an unexpected keyword argument '%s' to method create_health_check_templatesNzRMissing the required parameter `body` when calling `create_health_check_templates`r   r   r   r    r!   z:/CreateHealthCheckTemplates/2020-04-01/alb/get/text_plain/r"   "CreateHealthCheckTemplatesResponseTr$   r*   r5   s                  r   r\   z3ALBApi.create_health_check_templates_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% **''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  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ALBApi.create_listenerj  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/alb/get/text_plain/r"   CreateListenerResponseTr$   r*   r5   s                  r   rc   z%ALBApi.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ALBApi.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/alb/get/text_plain/r"   CreateLoadBalancerResponseTr$   r*   r5   s                  r   ri   z*ALBApi.create_load_balancer_with_http_info       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_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ALBApi.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/alb/get/text_plain/r"   CreateRulesResponseTr$   r*   r5   s                  r   rp   z"ALBApi.create_rules_with_http_infoA       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ALBApi.create_server_group  rI   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/alb/get/text_plain/r"   CreateServerGroupResponseTr$   r*   r5   s                  r   rw   z)ALBApi.create_server_group_with_http_info  rL   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ALBApi.delete_acl  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  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/alb/get/text_plain/r"   DeleteAclResponseTr$   r*   r5   s                  r   r|   z ALBApi.delete_acl_with_http_info  rS   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_ca_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_ca_certificate(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteCACertificateRequest body: (required)
        :return: DeleteCACertificateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $delete_ca_certificate_with_http_infor   s       r   delete_ca_certificatezALBApi.delete_ca_certificateO  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 )a  delete_ca_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_ca_certificate_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteCACertificateRequest body: (required)
        :return: DeleteCACertificateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method delete_ca_certificateNzJMissing the required parameter `body` when calling `delete_ca_certificate`r   r   r   r    r!   z3/DeleteCACertificate/2020-04-01/alb/get/text_plain/r"   DeleteCACertificateResponseTr$   r*   r5   s                  r   r   z+ALBApi.delete_ca_certificate_with_http_infod  rZ   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ALBApi.delete_certificate  ]     ,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/alb/get/text_plain/r"   DeleteCertificateResponseTr$   r*   r5   s                  r   r   z(ALBApi.delete_certificate_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% **''?#!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_customized_cfg  # 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_customized_cfg(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteCustomizedCfgRequest body: (required)
        :return: DeleteCustomizedCfgResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $delete_customized_cfg_with_http_infor   s       r   delete_customized_cfgzALBApi.delete_customized_cfg  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 )a  delete_customized_cfg  # 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_customized_cfg_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteCustomizedCfgRequest body: (required)
        :return: DeleteCustomizedCfgResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method delete_customized_cfgNzJMissing the required parameter `body` when calling `delete_customized_cfg`r   r   r   r    r!   z3/DeleteCustomizedCfg/2020-04-01/alb/get/text_plain/r"   DeleteCustomizedCfgResponseTr$   r*   r5   s                  r   r   z+ALBApi.delete_customized_cfg_with_http_info&  rZ   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a)  delete_health_check_templates  # 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_templates(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteHealthCheckTemplatesRequest body: (required)
        :return: DeleteHealthCheckTemplatesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   ,delete_health_check_templates_with_http_infor   s       r   delete_health_check_templatesz$ALBApi.delete_health_check_templatesr  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 )a8  delete_health_check_templates  # 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_templates_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteHealthCheckTemplatesRequest body: (required)
        :return: DeleteHealthCheckTemplatesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zOGot an unexpected keyword argument '%s' to method delete_health_check_templatesNzRMissing the required parameter `body` when calling `delete_health_check_templates`r   r   r   r    r!   z:/DeleteHealthCheckTemplates/2020-04-01/alb/get/text_plain/r"   "DeleteHealthCheckTemplatesResponseTr$   r*   r5   s                  r   r   z3ALBApi.delete_health_check_templates_with_http_info  ra   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ALBApi.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/alb/get/text_plain/r"   DeleteListenerResponseTr$   r*   r5   s                  r   r   z%ALBApi.delete_listener_with_http_info  rg   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ALBApi.delete_load_balancer4  rk   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/alb/get/text_plain/r"   DeleteLoadBalancerResponseTr$   r*   r5   s                  r   r   z*ALBApi.delete_load_balancer_with_http_infoI  rn   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ALBApi.delete_rules  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_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/alb/get/text_plain/r"   DeleteRulesResponseTr$   r*   r5   s                  r   r   z"ALBApi.delete_rules_with_http_info  ru   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ALBApi.delete_server_group  rI   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/alb/get/text_plain/r"   DeleteServerGroupResponseTr$   r*   r5   s                  r   r   z)ALBApi.delete_server_group_with_http_info  rL   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ALBApi.describe_acl_attributesW  ]     ,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"  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/alb/get/text_plain/r"   DescribeAclAttributesResponseTr$   r*   r5   s                  r   r   z-ALBApi.describe_acl_attributes_with_http_infol       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ALBApi.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/alb/get/text_plain/r"   DescribeAclsResponseTr$   r*   r5   s                  r   r   z#ALBApi.describe_acls_with_http_info       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_all_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_all_certificates(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeAllCertificatesRequest body: (required)
        :return: DescribeAllCertificatesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   (describe_all_certificates_with_http_infor   s       r   describe_all_certificatesz ALBApi.describe_all_certificates  ]     ,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*  describe_all_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_all_certificates_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeAllCertificatesRequest body: (required)
        :return: DescribeAllCertificatesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zKGot an unexpected keyword argument '%s' to method describe_all_certificatesNzNMissing the required parameter `body` when calling `describe_all_certificates`r   r   r   r    r!   z7/DescribeAllCertificates/2020-04-01/alb/get/text_plain/r"   DescribeAllCertificatesResponseTr$   r*   r5   s                  r   r   z/ALBApi.describe_all_certificates_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% **''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  describe_ca_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_ca_certificates(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeCACertificatesRequest body: (required)
        :return: DescribeCACertificatesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'describe_ca_certificates_with_http_infor   s       r   describe_ca_certificateszALBApi.describe_ca_certificatesz  ]     ,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_ca_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_ca_certificates_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeCACertificatesRequest body: (required)
        :return: DescribeCACertificatesResponse
                 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_ca_certificatesNzMMissing the required parameter `body` when calling `describe_ca_certificates`r   r   r   r    r!   z6/DescribeCACertificates/2020-04-01/alb/get/text_plain/r"   DescribeCACertificatesResponseTr$   r*   r5   s                  r   r   z.ALBApi.describe_ca_certificates_with_http_info      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_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ALBApi.describe_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 )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/alb/get/text_plain/r"   DescribeCertificatesResponseTr$   r*   r5   s                  r   r   z+ALBApi.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 )a=  describe_customized_cfg_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_customized_cfg_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeCustomizedCfgAttributesRequest body: (required)
        :return: DescribeCustomizedCfgAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   1describe_customized_cfg_attributes_with_http_infor   s       r   "describe_customized_cfg_attributesz)ALBApi.describe_customized_cfg_attributes<	  s_     ,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 )aL  describe_customized_cfg_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_customized_cfg_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeCustomizedCfgAttributesRequest body: (required)
        :return: DescribeCustomizedCfgAttributesResponse
                 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_customized_cfg_attributesNzWMissing the required parameter `body` when calling `describe_customized_cfg_attributes`r   r   r   r    r!   z?/DescribeCustomizedCfgAttributes/2020-04-01/alb/get/text_plain/r"   'DescribeCustomizedCfgAttributesResponseTr$   r*   r5   s                  r   r   z8ALBApi.describe_customized_cfg_attributes_with_http_infoQ	  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_customized_cfgs  # 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_customized_cfgs(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeCustomizedCfgsRequest body: (required)
        :return: DescribeCustomizedCfgsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'describe_customized_cfgs_with_http_infor   s       r   describe_customized_cfgszALBApi.describe_customized_cfgs	  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_customized_cfgs  # 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_customized_cfgs_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeCustomizedCfgsRequest body: (required)
        :return: DescribeCustomizedCfgsResponse
                 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_customized_cfgsNzMMissing the required parameter `body` when calling `describe_customized_cfgs`r   r   r   r    r!   z6/DescribeCustomizedCfgs/2020-04-01/alb/get/text_plain/r"   DescribeCustomizedCfgsResponseTr$   r*   r5   s                  r   r   z.ALBApi.describe_customized_cfgs_with_http_info	  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a1  describe_health_check_templates  # 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_templates(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeHealthCheckTemplatesRequest body: (required)
        :return: DescribeHealthCheckTemplatesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   .describe_health_check_templates_with_http_infor   s       r   describe_health_check_templatesz&ALBApi.describe_health_check_templates	  ^     ,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@  describe_health_check_templates  # 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_templates_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeHealthCheckTemplatesRequest body: (required)
        :return: DescribeHealthCheckTemplatesResponse
                 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_health_check_templatesNzTMissing the required parameter `body` when calling `describe_health_check_templates`r   r   r   r    r!   z</DescribeHealthCheckTemplates/2020-04-01/alb/get/text_plain/r"   $DescribeHealthCheckTemplatesResponseTr$   r*   r5   s                  r   r   z5ALBApi.describe_health_check_templates_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 )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#ALBApi.describe_listener_attributes_
  s]     ,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 )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/alb/get/text_plain/r"   "DescribeListenerAttributesResponseTr$   r*   r5   s                  r   r   z2ALBApi.describe_listener_attributes_with_http_infot
  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ALBApi.describe_listener_health
  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_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/alb/get/text_plain/r"   DescribeListenerHealthResponseTr$   r*   r5   s                  r   r   z.ALBApi.describe_listener_health_with_http_info
  r   r   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ALBApi.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/alb/get/text_plain/r"   DescribeListenersResponseTr$   r*   r5   s                  r   r   z(ALBApi.describe_listeners_with_http_info6  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(ALBApi.describe_load_balancer_attributes  s_     ,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/alb/get/text_plain/r"   &DescribeLoadBalancerAttributesResponseTr$   r*   r5   s                  r   r   z7ALBApi.describe_load_balancer_attributes_with_http_info  s    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_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ALBApi.describe_load_balancers  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_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/alb/get/text_plain/r"   DescribeLoadBalancersResponseTr$   r*   r5   s                  r   r   z-ALBApi.describe_load_balancers_with_http_info  r   r   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ALBApi.describe_rulesD  ]     ,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/alb/get/text_plain/r"   DescribeRulesResponseTr$   r*   r5   s                  r   r   z$ALBApi.describe_rules_with_http_infoY       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'ALBApi.describe_server_group_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 )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/alb/get/text_plain/r"   %DescribeServerGroupAttributesResponseTr$   r*   r5   s                  r   r   z6ALBApi.describe_server_group_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 )aG  describe_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.describe_server_group_backend_servers(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeServerGroupBackendServersRequest body: (required)
        :return: DescribeServerGroupBackendServersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   4describe_server_group_backend_servers_with_http_infor   s       r   %describe_server_group_backend_serversz,ALBApi.describe_server_group_backend_servers  s_     ,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_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.describe_server_group_backend_servers_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeServerGroupBackendServersRequest body: (required)
        :return: DescribeServerGroupBackendServersResponse
                 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_server_group_backend_serversNzZMissing the required parameter `body` when calling `describe_server_group_backend_servers`r   r   r   r    r!   zA/DescribeServerGroupBackendServers/2020-04-01/alb/get/text_plain/r"   )DescribeServerGroupBackendServersResponseTr$   r*   r5   s                  r   r  z;ALBApi.describe_server_group_backend_servers_with_http_info  s    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_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ALBApi.describe_server_groupsg  ]     ,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_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/alb/get/text_plain/r"   DescribeServerGroupsResponseTr$   r*   r5   s                  r   r  z,ALBApi.describe_server_groups_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_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ALBApi.describe_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_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/alb/get/text_plain/r"   DescribeZonesResponseTr$   r*   r5   s                  r   r  z$ALBApi.describe_zones_with_http_info  r   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ALBApi.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/alb/get/text_plain/r"   DisableAccessLogResponseTr$   r*   r5   s                  r   r  z(ALBApi.disable_access_log_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  disable_health_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_health_log(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DisableHealthLogRequest body: (required)
        :return: DisableHealthLogResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !disable_health_log_with_http_infor   s       r   disable_health_logzALBApi.disable_health_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_health_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_health_log_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DisableHealthLogRequest body: (required)
        :return: DisableHealthLogResponse
                 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_health_logNzGMissing the required parameter `body` when calling `disable_health_log`r   r   r   r    r!   z0/DisableHealthLog/2020-04-01/alb/get/text_plain/r"   DisableHealthLogResponseTr$   r*   r5   s                  r   r  z(ALBApi.disable_health_log_with_http_info  r  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  disable_tls_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_tls_access_log(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DisableTLSAccessLogRequest body: (required)
        :return: DisableTLSAccessLogResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   %disable_tls_access_log_with_http_infor   s       r   disable_tls_access_logzALBApi.disable_tls_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_tls_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_tls_access_log_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DisableTLSAccessLogRequest body: (required)
        :return: DisableTLSAccessLogResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method disable_tls_access_logNzKMissing the required parameter `body` when calling `disable_tls_access_log`r   r   r   r    r!   z3/DisableTLSAccessLog/2020-04-01/alb/get/text_plain/r"   DisableTLSAccessLogResponseTr$   r*   r5   s                  r   r  z,ALBApi.disable_tls_access_log_with_http_info   s     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% **''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  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ALBApi.enable_access_logL  ]     ,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/alb/get/text_plain/r"   EnableAccessLogResponseTr$   r*   r5   s                  r   r#  z'ALBApi.enable_access_log_with_http_infoa       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  enable_health_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_health_log(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableHealthLogRequest body: (required)
        :return: EnableHealthLogResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r    enable_health_log_with_http_infor   s       r   enable_health_logzALBApi.enable_health_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
  enable_health_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_health_log_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableHealthLogRequest body: (required)
        :return: EnableHealthLogResponse
                 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_health_logNzFMissing the required parameter `body` when calling `enable_health_log`r   r   r   r    r!   z//EnableHealthLog/2020-04-01/alb/get/text_plain/r"   EnableHealthLogResponseTr$   r*   r5   s                  r   r*  z'ALBApi.enable_health_log_with_http_info  r(  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a	  enable_tls_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_tls_access_log(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableTLSAccessLogRequest body: (required)
        :return: EnableTLSAccessLogResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $enable_tls_access_log_with_http_infor   s       r   enable_tls_access_logzALBApi.enable_tls_access_log  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 )a  enable_tls_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_tls_access_log_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableTLSAccessLogRequest body: (required)
        :return: EnableTLSAccessLogResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method enable_tls_access_logNzJMissing the required parameter `body` when calling `enable_tls_access_log`r   r   r   r    r!   z2/EnableTLSAccessLog/2020-04-01/alb/get/text_plain/r"   EnableTLSAccessLogResponseTr$   r*   r5   s                  r   r/  z+ALBApi.enable_tls_access_log_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% **''@%#!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  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ALBApi.list_tags_for_resourceso  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   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/alb/get/text_plain/r"   ListTagsForResourcesResponseTr$   r*   r5   s                  r   r4  z-ALBApi.list_tags_for_resources_with_http_info  s     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 )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ALBApi.modify_acl_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 )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/alb/get/text_plain/r"   ModifyAclAttributesResponseTr$   r*   r5   s                  r   r9  z+ALBApi.modify_acl_attributes_with_http_info  rZ   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a5  modify_ca_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_ca_certificate_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyCACertificateAttributesRequest body: (required)
        :return: ModifyCACertificateAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   /modify_ca_certificate_attributes_with_http_infor   s       r    modify_ca_certificate_attributesz'ALBApi.modify_ca_certificate_attributes1  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 )aD  modify_ca_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_ca_certificate_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyCACertificateAttributesRequest body: (required)
        :return: ModifyCACertificateAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zRGot an unexpected keyword argument '%s' to method modify_ca_certificate_attributesNzUMissing the required parameter `body` when calling `modify_ca_certificate_attributes`r   r   r   r    r!   z=/ModifyCACertificateAttributes/2020-04-01/alb/get/text_plain/r"   %ModifyCACertificateAttributesResponseTr$   r*   r5   s                  r   r>  z6ALBApi.modify_ca_certificate_attributes_with_http_infoF  r   r   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$ALBApi.modify_certificate_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_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/alb/get/text_plain/r"   #ModifyCertificateAttributesResponseTr$   r*   r5   s                  r   rC  z3ALBApi.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 )a5  modify_customized_cfg_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_customized_cfg_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyCustomizedCfgAttributesRequest body: (required)
        :return: ModifyCustomizedCfgAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   /modify_customized_cfg_attributes_with_http_infor   s       r    modify_customized_cfg_attributesz'ALBApi.modify_customized_cfg_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 )aD  modify_customized_cfg_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_customized_cfg_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyCustomizedCfgAttributesRequest body: (required)
        :return: ModifyCustomizedCfgAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zRGot an unexpected keyword argument '%s' to method modify_customized_cfg_attributesNzUMissing the required parameter `body` when calling `modify_customized_cfg_attributes`r   r   r   r    r!   z=/ModifyCustomizedCfgAttributes/2020-04-01/alb/get/text_plain/r"   %ModifyCustomizedCfgAttributesResponseTr$   r*   r5   s                  r   rH  z6ALBApi.modify_customized_cfg_attributes_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )aS  modify_health_check_templates_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_health_check_templates_attributes(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyHealthCheckTemplatesAttributesRequest body: (required)
        :return: ModifyHealthCheckTemplatesAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   7modify_health_check_templates_attributes_with_http_infor   s       r   (modify_health_check_templates_attributesz/ALBApi.modify_health_check_templates_attributesT  sa     ,0'(::k"" 	O4OPT__X^___QTQRVaaZ`aaT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  modify_health_check_templates_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_health_check_templates_attributes_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyHealthCheckTemplatesAttributesRequest body: (required)
        :return: ModifyHealthCheckTemplatesAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zZGot an unexpected keyword argument '%s' to method modify_health_check_templates_attributesNz]Missing the required parameter `body` when calling `modify_health_check_templates_attributes`r   r   r   r    r!   zD/ModifyHealthCheckTemplatesAttributes/2020-04-01/alb/get/text_plain/r"   ,ModifyHealthCheckTemplatesAttributesResponseTr$   r*   r5   s                  r   rM  z>ALBApi.modify_health_check_templates_attributes_with_http_infoi  s    X
+&&&2333,---,---fX&677 	 	HC*$$JLOP   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 )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!ALBApi.modify_listener_attributes  ]     ,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.  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/alb/get/text_plain/r"    ModifyListenerAttributesResponseTr$   r*   r5   s                  r   rR  z0ALBApi.modify_listener_attributes_with_http_info  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 )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&ALBApi.modify_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_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/alb/get/text_plain/r"   $ModifyLoadBalancerAttributesResponseTr$   r*   r5   s                  r   rX  z5ALBApi.modify_load_balancer_attributes_with_http_info+  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  modify_load_balancer_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_load_balancer_type(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyLoadBalancerTypeRequest body: (required)
        :return: ModifyLoadBalancerTypeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   (modify_load_balancer_type_with_http_infor   s       r   modify_load_balancer_typez ALBApi.modify_load_balancer_typew  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_load_balancer_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_load_balancer_type_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyLoadBalancerTypeRequest body: (required)
        :return: ModifyLoadBalancerTypeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zKGot an unexpected keyword argument '%s' to method modify_load_balancer_typeNzNMissing the required parameter `body` when calling `modify_load_balancer_type`r   r   r   r    r!   z6/ModifyLoadBalancerType/2020-04-01/alb/get/text_plain/r"   ModifyLoadBalancerTypeResponseTr$   r*   r5   s                  r   r]  z/ALBApi.modify_load_balancer_type_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  modify_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_load_balancer_zones(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyLoadBalancerZonesRequest body: (required)
        :return: ModifyLoadBalancerZonesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )modify_load_balancer_zones_with_http_infor   s       r   modify_load_balancer_zonesz!ALBApi.modify_load_balancer_zones  rT  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_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_load_balancer_zones_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyLoadBalancerZonesRequest body: (required)
        :return: ModifyLoadBalancerZonesResponse
                 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_load_balancer_zonesNzOMissing the required parameter `body` when calling `modify_load_balancer_zones`r   r   r   r    r!   z7/ModifyLoadBalancerZones/2020-04-01/alb/get/text_plain/r"   ModifyLoadBalancerZonesResponseTr$   r*   r5   s                  r   rb  z0ALBApi.modify_load_balancer_zones_with_http_info  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% **''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  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ALBApi.modify_rules9  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  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/alb/get/text_plain/r"   ModifyRulesResponseTr$   r*   r5   s                  r   rg  z"ALBApi.modify_rules_with_http_infoN  ru   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%ALBApi.modify_server_group_attributes  s^     ,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<  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/alb/get/text_plain/r"   #ModifyServerGroupAttributesResponseTr$   r*   r5   s                  r   rl  z4ALBApi.modify_server_group_attributes_with_http_info  s    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 )a?  modify_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.modify_server_group_backend_servers(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyServerGroupBackendServersRequest body: (required)
        :return: ModifyServerGroupBackendServersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   2modify_server_group_backend_servers_with_http_infor   s       r   #modify_server_group_backend_serversz*ALBApi.modify_server_group_backend_servers  _     ,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  modify_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.modify_server_group_backend_servers_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyServerGroupBackendServersRequest body: (required)
        :return: ModifyServerGroupBackendServersResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zUGot an unexpected keyword argument '%s' to method modify_server_group_backend_serversNzXMissing the required parameter `body` when calling `modify_server_group_backend_servers`r   r   r   r    r!   z?/ModifyServerGroupBackendServers/2020-04-01/alb/get/text_plain/r"   'ModifyServerGroupBackendServersResponseTr$   r*   r5   s                  r   rq  z9ALBApi.modify_server_group_backend_servers_with_http_info      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  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ALBApi.remove_acl_entries\  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/alb/get/text_plain/r"   RemoveAclEntriesResponseTr$   r*   r5   s                  r   rx  z(ALBApi.remove_acl_entries_with_http_infoq  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*ALBApi.remove_server_group_backend_servers  rs  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 )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/alb/get/text_plain/r"   'RemoveServerGroupBackendServersResponseTr$   r*   r5   s                  r   r}  z9ALBApi.remove_server_group_backend_servers_with_http_info  rv  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  replace_ca_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.replace_ca_certificate(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ReplaceCACertificateRequest body: (required)
        :return: ReplaceCACertificateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   %replace_ca_certificate_with_http_infor   s       r   replace_ca_certificatezALBApi.replace_ca_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  replace_ca_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.replace_ca_certificate_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ReplaceCACertificateRequest body: (required)
        :return: ReplaceCACertificateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method replace_ca_certificateNzKMissing the required parameter `body` when calling `replace_ca_certificate`r   r   r   r    r!   z4/ReplaceCACertificate/2020-04-01/alb/get/text_plain/r"   ReplaceCACertificateResponseTr$   r*   r5   s                  r   r  z,ALBApi.replace_ca_certificate_with_http_info3  r  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  replace_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.replace_certificate(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ReplaceCertificateRequest body: (required)
        :return: ReplaceCertificateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "replace_certificate_with_http_infor   s       r   replace_certificatezALBApi.replace_certificate  rI   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  replace_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.replace_certificate_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ReplaceCertificateRequest body: (required)
        :return: ReplaceCertificateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zEGot an unexpected keyword argument '%s' to method replace_certificateNzHMissing the required parameter `body` when calling `replace_certificate`r   r   r   r    r!   z2/ReplaceCertificate/2020-04-01/alb/get/text_plain/r"   ReplaceCertificateResponseTr$   r*   r5   s                  r   r  z)ALBApi.replace_certificate_with_http_info  s     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% **''@%#!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  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ALBApi.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/alb/get/text_plain/r"   TagResourcesResponseTr$   r*   r5   s                  r   r  z#ALBApi.tag_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ALBApi.untag_resourcesA  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/alb/get/text_plain/r"   UntagResourcesResponseTr$   r*   r5   s                  r   r  z%ALBApi.untag_resources_with_http_infoV  rg   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  upload_ca_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_ca_certificate(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param UploadCACertificateRequest body: (required)
        :return: UploadCACertificateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $upload_ca_certificate_with_http_infor   s       r   upload_ca_certificatezALBApi.upload_ca_certificate  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 )a  upload_ca_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_ca_certificate_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param UploadCACertificateRequest body: (required)
        :return: UploadCACertificateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method upload_ca_certificateNzJMissing the required parameter `body` when calling `upload_ca_certificate`r   r   r   r    r!   z3/UploadCACertificate/2020-04-01/alb/get/text_plain/r"   UploadCACertificateResponseTr$   r*   r5   s                  r   r  z+ALBApi.upload_ca_certificate_with_http_info  rZ   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ALBApi.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/alb/get/text_plain/r"   UploadCertificateResponseTr$   r*   r5   s                  r   r  z(ALBApi.upload_certificate_with_http_info  r   r   r   )__name__
__module____qualname____doc__r   r   r   rB   rA   rH   rG   rO   rN   rV   rU   r]   r\   rd   rc   rj   ri   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*  r0  r/  r5  r4  r:  r9  r?  r>  rD  rC  rI  rH  rN  rM  rS  rR  rY  rX  r^  r]  rc  rb  rh  rg  rm  rl  rr  rq  ry  rx  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3 J3 J3r   r   )r  
__future__r   rer-   r   objectr   r  r   r   <module>r     s     ' & & & & & 				 


    Ja3 Ja3 Ja3 Ja3 Ja3V Ja3 Ja3 Ja3 Ja3 Ja3r   