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

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

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

        :param async_req bool
        :param AddRouteAggregationRequest body: (required)
        :return: AddRouteAggregationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        T_return_http_data_only	async_req)get$add_route_aggregation_with_http_infor   bodykwargsdatas       r   add_route_aggregationzEDXApi.add_route_aggregation$   ]     ,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  add_route_aggregation  # 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_route_aggregation_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param AddRouteAggregationRequest body: (required)
        :return: AddRouteAggregationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   _preload_content_request_timeoutr   zGGot an unexpected keyword argument '%s' to method add_route_aggregationNzJMissing the required parameter `body` when calling `add_route_aggregation`application/jsonAcceptContent-TypevolcengineSignz:/AddRouteAggregation/2023-04-20/edx/post/application_json/POSTAddRouteAggregationResponseT
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+EDXApi.add_route_aggregation_with_http_info9       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% **''H&#!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 )a7  agree_cross_account_vif_authority  # noqa: E501

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

        :param async_req bool
        :param AgreeCrossAccountVIFAuthorityRequest body: (required)
        :return: AgreeCrossAccountVIFAuthorityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   0agree_cross_account_vif_authority_with_http_infor   s       r   !agree_cross_account_vif_authorityz(EDXApi.agree_cross_account_vif_authority   _     ,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 )aF  agree_cross_account_vif_authority  # noqa: E501

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

        :param async_req bool
        :param AgreeCrossAccountVIFAuthorityRequest body: (required)
        :return: AgreeCrossAccountVIFAuthorityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zSGot an unexpected keyword argument '%s' to method agree_cross_account_vif_authorityNzVMissing the required parameter `body` when calling `agree_cross_account_vif_authority`r   r   r   r    zD/AgreeCrossAccountVIFAuthority/2023-04-20/edx/post/application_json/r!   %AgreeCrossAccountVIFAuthorityResponseTr#   r)   r4   s                  r   rA   z7EDXApi.agree_cross_account_vif_authority_with_http_info       X
+&&&2333,---,---fX&677 	 	HC*$$CEHI   F3KK8?1 	wvV7K7K7=f~7MuvvvV .K"&/"F"F #" #"h )-(R(R )" )"n% **''RTZ#!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 )a7  apply_cross_account_vif_authority  # noqa: E501

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

        :param async_req bool
        :param ApplyCrossAccountVIFAuthorityRequest body: (required)
        :return: ApplyCrossAccountVIFAuthorityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   0apply_cross_account_vif_authority_with_http_infor   s       r   !apply_cross_account_vif_authorityz(EDXApi.apply_cross_account_vif_authority   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 )aF  apply_cross_account_vif_authority  # noqa: E501

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

        :param async_req bool
        :param ApplyCrossAccountVIFAuthorityRequest body: (required)
        :return: ApplyCrossAccountVIFAuthorityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zSGot an unexpected keyword argument '%s' to method apply_cross_account_vif_authorityNzVMissing the required parameter `body` when calling `apply_cross_account_vif_authority`r   r   r   r    zD/ApplyCrossAccountVIFAuthority/2023-04-20/edx/post/application_json/r!   %ApplyCrossAccountVIFAuthorityResponseTr#   r)   r4   s                  r   rH   z7EDXApi.apply_cross_account_vif_authority_with_http_info   rF   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a;  cancel_cross_account_vif_authority  # noqa: E501

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

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

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

        :param async_req bool
        :param CancelCrossAccountVIFAuthorityRequest body: (required)
        :return: CancelCrossAccountVIFAuthorityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zTGot an unexpected keyword argument '%s' to method cancel_cross_account_vif_authorityNzWMissing the required parameter `body` when calling `cancel_cross_account_vif_authority`r   r   r   r    zE/CancelCrossAccountVIFAuthority/2023-04-20/edx/post/application_json/r!   &CancelCrossAccountVIFAuthorityResponseTr#   r)   r4   s                  r   rM   z8EDXApi.cancel_cross_account_vif_authority_with_http_info\      X
+&&&2333,---,---fX&677 	 	HC*$$DFIJ   F3KK8?1 	xvV7K7K7=f~7MvwwwV .K"&/"F"F #" #"h )-(R(R )" )"n% **''SU[#!B'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_dxp_connection  # 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_dxp_connection(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateDXPConnectionRequest body: (required)
        :return: CreateDXPConnectionResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $create_dxp_connection_with_http_infor   s       r   create_dxp_connectionzEDXApi.create_dxp_connection  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_dxp_connection  # 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_dxp_connection_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateDXPConnectionRequest body: (required)
        :return: CreateDXPConnectionResponse
                 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_dxp_connectionNzJMissing the required parameter `body` when calling `create_dxp_connection`r   r   r   r    z:/CreateDXPConnection/2023-04-20/edx/post/application_json/r!   CreateDXPConnectionResponseTr#   r)   r4   s                  r   rT   z+EDXApi.create_dxp_connection_with_http_info  r?   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a!  create_dxp_connection_order  # 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_dxp_connection_order(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateDXPConnectionOrderRequest body: (required)
        :return: CreateDXPConnectionOrderResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   *create_dxp_connection_order_with_http_infor   s       r   create_dxp_connection_orderz"EDXApi.create_dxp_connection_order	  ]     ,0'(::k"" 	B4B4RR6RRRDTDTTTVTTTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a0  create_dxp_connection_order  # 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_dxp_connection_order_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateDXPConnectionOrderRequest body: (required)
        :return: CreateDXPConnectionOrderResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zMGot an unexpected keyword argument '%s' to method create_dxp_connection_orderNzPMissing the required parameter `body` when calling `create_dxp_connection_order`r   r   r   r    z?/CreateDXPConnectionOrder/2023-04-20/edx/post/application_json/r!    CreateDXPConnectionOrderResponseTr#   r)   r4   s                  r   rY   z1EDXApi.create_dxp_connection_order_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$=?BC   F3KK8?1 	qvV7K7K7=f~7MopppV .K"&/"F"F #" #"h )-(R(R )" )"n% **''Mv#!<'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_dxp_instance  # 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_dxp_instance(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateDXPInstanceRequest body: (required)
        :return: CreateDXPInstanceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "create_dxp_instance_with_http_infor   s       r   create_dxp_instancezEDXApi.create_dxp_instancej  ]     ,0'(::k"" 	:4:4JJ6JJJ<T<TLLVLLTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  create_dxp_instance  # 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_dxp_instance_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateDXPInstanceRequest body: (required)
        :return: CreateDXPInstanceResponse
                 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_dxp_instanceNzHMissing the required parameter `body` when calling `create_dxp_instance`r   r   r   r    z8/CreateDXPInstance/2023-04-20/edx/post/application_json/r!   CreateDXPInstanceResponseTr#   r)   r4   s                  r   r_   z)EDXApi.create_dxp_instance_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% **''F#!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_edx  # 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_edx(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateEDXRequest body: (required)
        :return: CreateEDXResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   create_edx_with_http_infor   s       r   
create_edxzEDXApi.create_edx  ]     ,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_edx  # 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_edx_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateEDXRequest body: (required)
        :return: CreateEDXResponse
                 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_edxNz?Missing the required parameter `body` when calling `create_edx`r   r   r   r    z0/CreateEDX/2023-04-20/edx/post/application_json/r!   CreateEDXResponseTr#   r)   r4   s                  r   rf   z EDXApi.create_edx_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% **''>#!-'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_edx_bandwidth_pkg  # 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_edx_bandwidth_pkg(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateEDXBandwidthPkgRequest body: (required)
        :return: CreateEDXBandwidthPkgResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'create_edx_bandwidth_pkg_with_http_infor   s       r   create_edx_bandwidth_pkgzEDXApi.create_edx_bandwidth_pkg,  ]     ,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$  create_edx_bandwidth_pkg  # 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_edx_bandwidth_pkg_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateEDXBandwidthPkgRequest body: (required)
        :return: CreateEDXBandwidthPkgResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zJGot an unexpected keyword argument '%s' to method create_edx_bandwidth_pkgNzMMissing the required parameter `body` when calling `create_edx_bandwidth_pkg`r   r   r   r    z</CreateEDXBandwidthPkg/2023-04-20/edx/post/application_json/r!   CreateEDXBandwidthPkgResponseTr#   r)   r4   s                  r   rm   z.EDXApi.create_edx_bandwidth_pkg_with_http_infoA      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% **''JF#!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  create_edx_peer_link  # 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_edx_peer_link(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateEDXPeerLinkRequest body: (required)
        :return: CreateEDXPeerLinkResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #create_edx_peer_link_with_http_infor   s       r   create_edx_peer_linkzEDXApi.create_edx_peer_link  ]     ,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_edx_peer_link  # 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_edx_peer_link_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateEDXPeerLinkRequest body: (required)
        :return: CreateEDXPeerLinkResponse
                 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_edx_peer_linkNzIMissing the required parameter `body` when calling `create_edx_peer_link`r   r   r   r    z8/CreateEDXPeerLink/2023-04-20/edx/post/application_json/r!   CreateEDXPeerLinkResponseTr#   r)   r4   s                  r   rt   z*EDXApi.create_edx_peer_link_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% **''F#!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_virtual_interface  # noqa: E501

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

        :param async_req bool
        :param CreateVirtualInterfaceRequest body: (required)
        :return: CreateVirtualInterfaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'create_virtual_interface_with_http_infor   s       r   create_virtual_interfacezEDXApi.create_virtual_interface  ro   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_virtual_interface  # noqa: E501

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

        :param async_req bool
        :param CreateVirtualInterfaceRequest body: (required)
        :return: CreateVirtualInterfaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zJGot an unexpected keyword argument '%s' to method create_virtual_interfaceNzMMissing the required parameter `body` when calling `create_virtual_interface`r   r   r   r    z=/CreateVirtualInterface/2023-04-20/edx/post/application_json/r!   CreateVirtualInterfaceResponseTr#   r)   r4   s                  r   r{   z.EDXApi.create_virtual_interface_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% **''KV#!:'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_virtual_interface_bfd  # noqa: E501

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

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

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

        :param async_req bool
        :param CreateVirtualInterfaceBFDRequest body: (required)
        :return: CreateVirtualInterfaceBFDResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zNGot an unexpected keyword argument '%s' to method create_virtual_interface_bfdNzQMissing the required parameter `body` when calling `create_virtual_interface_bfd`r   r   r   r    z@/CreateVirtualInterfaceBFD/2023-04-20/edx/post/application_json/r!   !CreateVirtualInterfaceBFDResponseTr#   r)   r4   s                  r   r   z2EDXApi.create_virtual_interface_bfd_with_http_infod      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% **''NPV#!='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 )a7  create_virtual_interface_bgp_peer  # noqa: E501

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

        :param async_req bool
        :param CreateVirtualInterfaceBGPPeerRequest body: (required)
        :return: CreateVirtualInterfaceBGPPeerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   0create_virtual_interface_bgp_peer_with_http_infor   s       r   !create_virtual_interface_bgp_peerz(EDXApi.create_virtual_interface_bgp_peer  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 )aF  create_virtual_interface_bgp_peer  # noqa: E501

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

        :param async_req bool
        :param CreateVirtualInterfaceBGPPeerRequest body: (required)
        :return: CreateVirtualInterfaceBGPPeerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zSGot an unexpected keyword argument '%s' to method create_virtual_interface_bgp_peerNzVMissing the required parameter `body` when calling `create_virtual_interface_bgp_peer`r   r   r   r    zD/CreateVirtualInterfaceBGPPeer/2023-04-20/edx/post/application_json/r!   %CreateVirtualInterfaceBGPPeerResponseTr#   r)   r4   s                  r   r   z7EDXApi.create_virtual_interface_bgp_peer_with_http_info  rF   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a;  delete_cross_account_vif_authority  # 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_cross_account_vif_authority(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteCrossAccountVIFAuthorityRequest body: (required)
        :return: DeleteCrossAccountVIFAuthorityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   1delete_cross_account_vif_authority_with_http_infor   s       r   "delete_cross_account_vif_authorityz)EDXApi.delete_cross_account_vif_authority  rO   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aJ  delete_cross_account_vif_authority  # 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_cross_account_vif_authority_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteCrossAccountVIFAuthorityRequest body: (required)
        :return: DeleteCrossAccountVIFAuthorityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zTGot an unexpected keyword argument '%s' to method delete_cross_account_vif_authorityNzWMissing the required parameter `body` when calling `delete_cross_account_vif_authority`r   r   r   r    zE/DeleteCrossAccountVIFAuthority/2023-04-20/edx/post/application_json/r!   &DeleteCrossAccountVIFAuthorityResponseTr#   r)   r4   s                  r   r   z8EDXApi.delete_cross_account_vif_authority_with_http_info&  rR   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_dxp_instance  # 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_dxp_instance(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteDXPInstanceRequest body: (required)
        :return: DeleteDXPInstanceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "delete_dxp_instance_with_http_infor   s       r   delete_dxp_instancezEDXApi.delete_dxp_instancer  ra   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_dxp_instance  # 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_dxp_instance_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteDXPInstanceRequest body: (required)
        :return: DeleteDXPInstanceResponse
                 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_dxp_instanceNzHMissing the required parameter `body` when calling `delete_dxp_instance`r   r   r   r    z8/DeleteDXPInstance/2023-04-20/edx/post/application_json/r!   DeleteDXPInstanceResponseTr#   r)   r4   s                  r   r   z)EDXApi.delete_dxp_instance_with_http_info  rd   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_edx  # 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_edx(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteEDXRequest body: (required)
        :return: DeleteEDXResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   delete_edx_with_http_infor   s       r   
delete_edxzEDXApi.delete_edx  rh   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_edx  # 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_edx_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteEDXRequest body: (required)
        :return: DeleteEDXResponse
                 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_edxNz?Missing the required parameter `body` when calling `delete_edx`r   r   r   r    z0/DeleteEDX/2023-04-20/edx/post/application_json/r!   DeleteEDXResponseTr#   r)   r4   s                  r   r   z EDXApi.delete_edx_with_http_info  rk   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_edx_bandwidth_pkg  # 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_edx_bandwidth_pkg(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteEDXBandwidthPkgRequest body: (required)
        :return: DeleteEDXBandwidthPkgResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'delete_edx_bandwidth_pkg_with_http_infor   s       r   delete_edx_bandwidth_pkgzEDXApi.delete_edx_bandwidth_pkg4  ro   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_edx_bandwidth_pkg  # 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_edx_bandwidth_pkg_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteEDXBandwidthPkgRequest body: (required)
        :return: DeleteEDXBandwidthPkgResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zJGot an unexpected keyword argument '%s' to method delete_edx_bandwidth_pkgNzMMissing the required parameter `body` when calling `delete_edx_bandwidth_pkg`r   r   r   r    z</DeleteEDXBandwidthPkg/2023-04-20/edx/post/application_json/r!   DeleteEDXBandwidthPkgResponseTr#   r)   r4   s                  r   r   z.EDXApi.delete_edx_bandwidth_pkg_with_http_infoI  rr   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_edx_peer_link  # 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_edx_peer_link(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteEDXPeerLinkRequest body: (required)
        :return: DeleteEDXPeerLinkResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #delete_edx_peer_link_with_http_infor   s       r   delete_edx_peer_linkzEDXApi.delete_edx_peer_link  rv   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_edx_peer_link  # 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_edx_peer_link_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteEDXPeerLinkRequest body: (required)
        :return: DeleteEDXPeerLinkResponse
                 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_edx_peer_linkNzIMissing the required parameter `body` when calling `delete_edx_peer_link`r   r   r   r    z8/DeleteEDXPeerLink/2023-04-20/edx/post/application_json/r!   DeleteEDXPeerLinkResponseTr#   r)   r4   s                  r   r   z*EDXApi.delete_edx_peer_link_with_http_info  ry   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_route_aggregation  # 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_route_aggregation(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteRouteAggregationRequest body: (required)
        :return: DeleteRouteAggregationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'delete_route_aggregation_with_http_infor   s       r   delete_route_aggregationzEDXApi.delete_route_aggregation  ro   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_route_aggregation  # 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_route_aggregation_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteRouteAggregationRequest body: (required)
        :return: DeleteRouteAggregationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zJGot an unexpected keyword argument '%s' to method delete_route_aggregationNzMMissing the required parameter `body` when calling `delete_route_aggregation`r   r   r   r    z=/DeleteRouteAggregation/2023-04-20/edx/post/application_json/r!   DeleteRouteAggregationResponseTr#   r)   r4   s                  r   r   z.EDXApi.delete_route_aggregation_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_virtual_interface  # noqa: E501

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

        :param async_req bool
        :param DeleteVirtualInterfaceRequest body: (required)
        :return: DeleteVirtualInterfaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'delete_virtual_interface_with_http_infor   s       r   delete_virtual_interfacezEDXApi.delete_virtual_interfaceW  ro   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_virtual_interface  # noqa: E501

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

        :param async_req bool
        :param DeleteVirtualInterfaceRequest body: (required)
        :return: DeleteVirtualInterfaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zJGot an unexpected keyword argument '%s' to method delete_virtual_interfaceNzMMissing the required parameter `body` when calling `delete_virtual_interface`r   r   r   r    z=/DeleteVirtualInterface/2023-04-20/edx/post/application_json/r!   DeleteVirtualInterfaceResponseTr#   r)   r4   s                  r   r   z.EDXApi.delete_virtual_interface_with_http_infol  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a%  delete_virtual_interface_bfd  # noqa: E501

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

        :param async_req bool
        :param DeleteVirtualInterfaceBFDRequest body: (required)
        :return: DeleteVirtualInterfaceBFDResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   +delete_virtual_interface_bfd_with_http_infor   s       r   delete_virtual_interface_bfdz#EDXApi.delete_virtual_interface_bfd  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 )a4  delete_virtual_interface_bfd  # noqa: E501

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

        :param async_req bool
        :param DeleteVirtualInterfaceBFDRequest body: (required)
        :return: DeleteVirtualInterfaceBFDResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zNGot an unexpected keyword argument '%s' to method delete_virtual_interface_bfdNzQMissing the required parameter `body` when calling `delete_virtual_interface_bfd`r   r   r   r    z@/DeleteVirtualInterfaceBFD/2023-04-20/edx/post/application_json/r!   !DeleteVirtualInterfaceBFDResponseTr#   r)   r4   s                  r   r   z2EDXApi.delete_virtual_interface_bfd_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a7  delete_virtual_interface_bgp_peer  # noqa: E501

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

        :param async_req bool
        :param DeleteVirtualInterfaceBGPPeerRequest body: (required)
        :return: DeleteVirtualInterfaceBGPPeerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   0delete_virtual_interface_bgp_peer_with_http_infor   s       r   !delete_virtual_interface_bgp_peerz(EDXApi.delete_virtual_interface_bgp_peer  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 )aF  delete_virtual_interface_bgp_peer  # noqa: E501

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

        :param async_req bool
        :param DeleteVirtualInterfaceBGPPeerRequest body: (required)
        :return: DeleteVirtualInterfaceBGPPeerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zSGot an unexpected keyword argument '%s' to method delete_virtual_interface_bgp_peerNzVMissing the required parameter `body` when calling `delete_virtual_interface_bgp_peer`r   r   r   r    zD/DeleteVirtualInterfaceBGPPeer/2023-04-20/edx/post/application_json/r!   %DeleteVirtualInterfaceBGPPeerResponseTr#   r)   r4   s                  r   r   z7EDXApi.delete_virtual_interface_bgp_peer_with_http_info.  rF   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_edx  # 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_edx(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeEDXRequest body: (required)
        :return: DescribeEDXResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   describe_edx_with_http_infor   s       r   describe_edxzEDXApi.describe_edxz  s]     ,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  describe_edx  # 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_edx_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeEDXRequest body: (required)
        :return: DescribeEDXResponse
                 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_edxNzAMissing the required parameter `body` when calling `describe_edx`r   r   r   r    z2/DescribeEDX/2023-04-20/edx/post/application_json/r!   DescribeEDXResponseTr#   r)   r4   s                  r   r   z"EDXApi.describe_edx_with_http_info  s    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% **''@&#!/'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_virtual_interface  # 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_virtual_interface(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeVirtualInterfaceRequest body: (required)
        :return: DescribeVirtualInterfaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )describe_virtual_interface_with_http_infor   s       r   describe_virtual_interfacez!EDXApi.describe_virtual_interface  ]     ,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.  describe_virtual_interface  # 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_virtual_interface_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeVirtualInterfaceRequest body: (required)
        :return: DescribeVirtualInterfaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method describe_virtual_interfaceNzOMissing the required parameter `body` when calling `describe_virtual_interface`r   r   r   r    z?/DescribeVirtualInterface/2023-04-20/edx/post/application_json/r!    DescribeVirtualInterfaceResponseTr#   r)   r4   s                  r   r   z0EDXApi.describe_virtual_interface_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% **''Mv#!<'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_virtual_interface_bfd  # 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_virtual_interface_bfd(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeVirtualInterfaceBFDRequest body: (required)
        :return: DescribeVirtualInterfaceBFDResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   -describe_virtual_interface_bfd_with_http_infor   s       r   describe_virtual_interface_bfdz%EDXApi.describe_virtual_interface_bfd<	  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<  describe_virtual_interface_bfd  # 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_virtual_interface_bfd_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeVirtualInterfaceBFDRequest body: (required)
        :return: DescribeVirtualInterfaceBFDResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zPGot an unexpected keyword argument '%s' to method describe_virtual_interface_bfdNzSMissing the required parameter `body` when calling `describe_virtual_interface_bfd`r   r   r   r    zB/DescribeVirtualInterfaceBFD/2023-04-20/edx/post/application_json/r!   #DescribeVirtualInterfaceBFDResponseTr#   r)   r4   s                  r   r   z4EDXApi.describe_virtual_interface_bfd_with_http_infoQ	  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% **''PRX#!?'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_virtual_interface_bgp_peer  # 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_virtual_interface_bgp_peer(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeVirtualInterfaceBGPPeerRequest body: (required)
        :return: DescribeVirtualInterfaceBGPPeerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   2describe_virtual_interface_bgp_peer_with_http_infor   s       r   #describe_virtual_interface_bgp_peerz*EDXApi.describe_virtual_interface_bgp_peer	  s_     ,0'(::k"" 	J4J4ZZSYZZZLTLT\\U[\\TKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aN  describe_virtual_interface_bgp_peer  # 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_virtual_interface_bgp_peer_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeVirtualInterfaceBGPPeerRequest body: (required)
        :return: DescribeVirtualInterfaceBGPPeerResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zUGot an unexpected keyword argument '%s' to method describe_virtual_interface_bgp_peerNzXMissing the required parameter `body` when calling `describe_virtual_interface_bgp_peer`r   r   r   r    zF/DescribeVirtualInterfaceBGPPeer/2023-04-20/edx/post/application_json/r!   'DescribeVirtualInterfaceBGPPeerResponseTr#   r)   r4   s                  r   r   z9EDXApi.describe_virtual_interface_bgp_peer_with_http_info	  s    X
+&&&2333,---,---fX&677 	 	HC*$$EGJK   F3KK8?1 	yvV7K7K7=f~7MwxxxV .K"&/"F"F #" #"h )-(R(R )" )"n% **''TV\#!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  disable_route_aggregation  # 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_route_aggregation(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DisableRouteAggregationRequest body: (required)
        :return: DisableRouteAggregationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   (disable_route_aggregation_with_http_infor   s       r   disable_route_aggregationz EDXApi.disable_route_aggregation	  ]     ,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*  disable_route_aggregation  # 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_route_aggregation_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DisableRouteAggregationRequest body: (required)
        :return: DisableRouteAggregationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zKGot an unexpected keyword argument '%s' to method disable_route_aggregationNzNMissing the required parameter `body` when calling `disable_route_aggregation`r   r   r   r    z>/DisableRouteAggregation/2023-04-20/edx/post/application_json/r!   DisableRouteAggregationResponseTr#   r)   r4   s                  r   r   z/EDXApi.disable_route_aggregation_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% **''Lf#!;'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_route_aggregation  # 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_route_aggregation(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableRouteAggregationRequest body: (required)
        :return: EnableRouteAggregationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'enable_route_aggregation_with_http_infor   s       r   enable_route_aggregationzEDXApi.enable_route_aggregation_
  ro   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_route_aggregation  # 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_route_aggregation_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableRouteAggregationRequest body: (required)
        :return: EnableRouteAggregationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zJGot an unexpected keyword argument '%s' to method enable_route_aggregationNzMMissing the required parameter `body` when calling `enable_route_aggregation`r   r   r   r    z=/EnableRouteAggregation/2023-04-20/edx/post/application_json/r!   EnableRouteAggregationResponseTr#   r)   r4   s                  r   r   z.EDXApi.enable_route_aggregation_with_http_infot
  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_dxp_connection  # noqa: E501

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

        :param async_req bool
        :param GetDXPConnectionRequest body: (required)
        :return: GetDXPConnectionResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !get_dxp_connection_with_http_infor   s       r   get_dxp_connectionzEDXApi.get_dxp_connection
  ]     ,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  get_dxp_connection  # noqa: E501

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

        :param async_req bool
        :param GetDXPConnectionRequest body: (required)
        :return: GetDXPConnectionResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method get_dxp_connectionNzGMissing the required parameter `body` when calling `get_dxp_connection`r   r   r   r    z7/GetDXPConnection/2023-04-20/edx/post/application_json/r!   GetDXPConnectionResponseTr#   r)   r4   s                  r   r   z(EDXApi.get_dxp_connection_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% **''Ev#!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  get_dxp_construction_info  # noqa: E501

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

        :param async_req bool
        :param GetDXPConstructionInfoRequest body: (required)
        :return: GetDXPConstructionInfoResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   (get_dxp_construction_info_with_http_infor   s       r   get_dxp_construction_infoz EDXApi.get_dxp_construction_info!  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(  get_dxp_construction_info  # noqa: E501

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

        :param async_req bool
        :param GetDXPConstructionInfoRequest body: (required)
        :return: GetDXPConstructionInfoResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zKGot an unexpected keyword argument '%s' to method get_dxp_construction_infoNzNMissing the required parameter `body` when calling `get_dxp_construction_info`r   r   r   r    z=/GetDXPConstructionInfo/2023-04-20/edx/post/application_json/r!   GetDXPConstructionInfoResponseTr#   r)   r4   s                  r   r   z/EDXApi.get_dxp_construction_info_with_http_info6      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% **''KV#!:'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  get_dxp_construction_loa  # noqa: E501

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

        :param async_req bool
        :param GetDXPConstructionLOARequest body: (required)
        :return: GetDXPConstructionLOAResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'get_dxp_construction_loa_with_http_infor   s       r   get_dxp_construction_loazEDXApi.get_dxp_construction_loa  ro   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$  get_dxp_construction_loa  # noqa: E501

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

        :param async_req bool
        :param GetDXPConstructionLOARequest body: (required)
        :return: GetDXPConstructionLOAResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zJGot an unexpected keyword argument '%s' to method get_dxp_construction_loaNzMMissing the required parameter `body` when calling `get_dxp_construction_loa`r   r   r   r    z</GetDXPConstructionLOA/2023-04-20/edx/post/application_json/r!   GetDXPConstructionLOAResponseTr#   r)   r4   s                  r   r   z.EDXApi.get_dxp_construction_loa_with_http_info  rr   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_dxp_instance  # noqa: E501

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

        :param async_req bool
        :param GetDXPInstanceRequest body: (required)
        :return: GetDXPInstanceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   get_dxp_instance_with_http_infor   s       r   get_dxp_instancezEDXApi.get_dxp_instance  s]     ,0'(::k"" 	747GGGGG9T9$II&IIT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  get_dxp_instance  # noqa: E501

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

        :param async_req bool
        :param GetDXPInstanceRequest body: (required)
        :return: GetDXPInstanceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zBGot an unexpected keyword argument '%s' to method get_dxp_instanceNzEMissing the required parameter `body` when calling `get_dxp_instance`r   r   r   r    z5/GetDXPInstance/2023-04-20/edx/post/application_json/r!   GetDXPInstanceResponseTr#   r)   r4   s                  r   r   z&EDXApi.get_dxp_instance_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$2478   F3KK8?1 	fvV7K7K7=f~7MdeeeV .K"&/"F"F #" #"h )-(R(R )" )"n% **''CV#!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  get_dxp_monthly_rent  # noqa: E501

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

        :param async_req bool
        :param GetDXPMonthlyRentRequest body: (required)
        :return: GetDXPMonthlyRentResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #get_dxp_monthly_rent_with_http_infor   s       r   get_dxp_monthly_rentzEDXApi.get_dxp_monthly_rentD  rv   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  get_dxp_monthly_rent  # noqa: E501

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

        :param async_req bool
        :param GetDXPMonthlyRentRequest body: (required)
        :return: GetDXPMonthlyRentResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method get_dxp_monthly_rentNzIMissing the required parameter `body` when calling `get_dxp_monthly_rent`r   r   r   r    z8/GetDXPMonthlyRent/2023-04-20/edx/post/application_json/r!   GetDXPMonthlyRentResponseTr#   r)   r4   s                  r   r   z*EDXApi.get_dxp_monthly_rent_with_http_infoY  ry   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_dxp_port_price  # noqa: E501

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

        :param async_req bool
        :param GetDXPPortPriceRequest body: (required)
        :return: GetDXPPortPriceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !get_dxp_port_price_with_http_infor   s       r   get_dxp_port_pricezEDXApi.get_dxp_port_price  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  get_dxp_port_price  # noqa: E501

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

        :param async_req bool
        :param GetDXPPortPriceRequest body: (required)
        :return: GetDXPPortPriceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method get_dxp_port_priceNzGMissing the required parameter `body` when calling `get_dxp_port_price`r   r   r   r    z6/GetDXPPortPrice/2023-04-20/edx/post/application_json/r!   GetDXPPortPriceResponseTr#   r)   r4   s                  r   r   z(EDXApi.get_dxp_port_price_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% **''Df#!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  get_dxp_traffic_statistic  # noqa: E501

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

        :param async_req bool
        :param GetDXPTrafficStatisticRequest body: (required)
        :return: GetDXPTrafficStatisticResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   (get_dxp_traffic_statistic_with_http_infor   s       r   get_dxp_traffic_statisticz EDXApi.get_dxp_traffic_statistic  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(  get_dxp_traffic_statistic  # noqa: E501

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

        :param async_req bool
        :param GetDXPTrafficStatisticRequest body: (required)
        :return: GetDXPTrafficStatisticResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zKGot an unexpected keyword argument '%s' to method get_dxp_traffic_statisticNzNMissing the required parameter `body` when calling `get_dxp_traffic_statistic`r   r   r   r    z=/GetDXPTrafficStatistic/2023-04-20/edx/post/application_json/r!   GetDXPTrafficStatisticResponseTr#   r)   r4   s                  r   r   z/EDXApi.get_dxp_traffic_statistic_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_dxp_unit_price  # noqa: E501

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

        :param async_req bool
        :param GetDXPUnitPriceRequest body: (required)
        :return: GetDXPUnitPriceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !get_dxp_unit_price_with_http_infor   s       r   get_dxp_unit_pricezEDXApi.get_dxp_unit_priceg  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  get_dxp_unit_price  # noqa: E501

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

        :param async_req bool
        :param GetDXPUnitPriceRequest body: (required)
        :return: GetDXPUnitPriceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method get_dxp_unit_priceNzGMissing the required parameter `body` when calling `get_dxp_unit_price`r   r   r   r    z6/GetDXPUnitPrice/2023-04-20/edx/post/application_json/r!   GetDXPUnitPriceResponseTr#   r)   r4   s                  r   r  z(EDXApi.get_dxp_unit_price_with_http_info|  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_edx_bandwidth_left_cap  # noqa: E501

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

        :param async_req bool
        :param GetEDXBandwidthLeftCapRequest body: (required)
        :return: GetEDXBandwidthLeftCapResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )get_edx_bandwidth_left_cap_with_http_infor   s       r   get_edx_bandwidth_left_capz!EDXApi.get_edx_bandwidth_left_cap  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*  get_edx_bandwidth_left_cap  # noqa: E501

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

        :param async_req bool
        :param GetEDXBandwidthLeftCapRequest body: (required)
        :return: GetEDXBandwidthLeftCapResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method get_edx_bandwidth_left_capNzOMissing the required parameter `body` when calling `get_edx_bandwidth_left_cap`r   r   r   r    z=/GetEDXBandwidthLeftCap/2023-04-20/edx/post/application_json/r!   GetEDXBandwidthLeftCapResponseTr#   r)   r4   s                  r   r  z0EDXApi.get_edx_bandwidth_left_cap_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% **''KV#!:'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_available_edx  # 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_available_edx(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListAvailableEDXRequest body: (required)
        :return: ListAvailableEDXResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !list_available_edx_with_http_infor   s       r   list_available_edxzEDXApi.list_available_edx)  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_available_edx  # 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_available_edx_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListAvailableEDXRequest body: (required)
        :return: ListAvailableEDXResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method list_available_edxNzGMissing the required parameter `body` when calling `list_available_edx`r   r   r   r    z7/ListAvailableEDX/2023-04-20/edx/post/application_json/r!   ListAvailableEDXResponseTr#   r)   r4   s                  r   r  z(EDXApi.list_available_edx_with_http_info>  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a3  list_cross_account_vif_authority  # 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_cross_account_vif_authority(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListCrossAccountVIFAuthorityRequest body: (required)
        :return: ListCrossAccountVIFAuthorityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   /list_cross_account_vif_authority_with_http_infor   s       r    list_cross_account_vif_authorityz'EDXApi.list_cross_account_vif_authority  _     ,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  list_cross_account_vif_authority  # 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_cross_account_vif_authority_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListCrossAccountVIFAuthorityRequest body: (required)
        :return: ListCrossAccountVIFAuthorityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zRGot an unexpected keyword argument '%s' to method list_cross_account_vif_authorityNzUMissing the required parameter `body` when calling `list_cross_account_vif_authority`r   r   r   r    zC/ListCrossAccountVIFAuthority/2023-04-20/edx/post/application_json/r!   $ListCrossAccountVIFAuthorityResponseTr#   r)   r4   s                  r   r  z6EDXApi.list_cross_account_vif_authority_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% **''QSY#!@'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_dxp_access_points  # 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_dxp_access_points(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListDXPAccessPointsRequest body: (required)
        :return: ListDXPAccessPointsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   %list_dxp_access_points_with_http_infor   s       r   list_dxp_access_pointszEDXApi.list_dxp_access_points  ]     ,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  list_dxp_access_points  # 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_dxp_access_points_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListDXPAccessPointsRequest body: (required)
        :return: ListDXPAccessPointsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method list_dxp_access_pointsNzKMissing the required parameter `body` when calling `list_dxp_access_points`r   r   r   r    z:/ListDXPAccessPoints/2023-04-20/edx/post/application_json/r!   ListDXPAccessPointsResponseTr#   r)   r4   s                  r   r  z,EDXApi.list_dxp_access_points_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% **''H&#!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  list_dxp_instances  # 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_dxp_instances(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListDXPInstancesRequest body: (required)
        :return: ListDXPInstancesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !list_dxp_instances_with_http_infor   s       r   list_dxp_instanceszEDXApi.list_dxp_instancesL  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_dxp_instances  # 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_dxp_instances_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListDXPInstancesRequest body: (required)
        :return: ListDXPInstancesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method list_dxp_instancesNzGMissing the required parameter `body` when calling `list_dxp_instances`r   r   r   r    z7/ListDXPInstances/2023-04-20/edx/post/application_json/r!   ListDXPInstancesResponseTr#   r)   r4   s                  r   r  z(EDXApi.list_dxp_instances_with_http_infoa  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_dxp_specifications  # 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_dxp_specifications(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListDXPSpecificationsRequest body: (required)
        :return: ListDXPSpecificationsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &list_dxp_specifications_with_http_infor   s       r   list_dxp_specificationszEDXApi.list_dxp_specifications  s]     ,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"  list_dxp_specifications  # 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_dxp_specifications_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListDXPSpecificationsRequest body: (required)
        :return: ListDXPSpecificationsResponse
                 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_dxp_specificationsNzLMissing the required parameter `body` when calling `list_dxp_specifications`r   r   r   r    z</ListDXPSpecifications/2023-04-20/edx/post/application_json/r!   ListDXPSpecificationsResponseTr#   r)   r4   s                  r   r#  z-EDXApi.list_dxp_specifications_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% **''JF#!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  list_edx  # 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_edx(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListEDXRequest body: (required)
        :return: ListEDXResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   list_edx_with_http_infor   s       r   list_edxzEDXApi.list_edx  s]     ,0'(::k"" 	/4/?????1T1$AA&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 )a  list_edx  # 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_edx_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListEDXRequest body: (required)
        :return: ListEDXResponse
                 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 list_edxNz=Missing the required parameter `body` when calling `list_edx`r   r   r   r    z./ListEDX/2023-04-20/edx/post/application_json/r!   ListEDXResponseTr#   r)   r4   s                  r   r(  zEDXApi.list_edx_with_http_info#  s    X
+&&&2333,---,---fX&677 	 	HC*$$*,/0   F3KK8?1 	^vV7K7K7=f~7M\]]]V .K"&/"F"F #" #"h )-(R(R )" )"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 )a3  list_edx_associated_vgw_topology  # 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_edx_associated_vgw_topology(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListEDXAssociatedVGWTopologyRequest body: (required)
        :return: ListEDXAssociatedVGWTopologyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   /list_edx_associated_vgw_topology_with_http_infor   s       r    list_edx_associated_vgw_topologyz'EDXApi.list_edx_associated_vgw_topologyo  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 )aB  list_edx_associated_vgw_topology  # 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_edx_associated_vgw_topology_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListEDXAssociatedVGWTopologyRequest body: (required)
        :return: ListEDXAssociatedVGWTopologyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zRGot an unexpected keyword argument '%s' to method list_edx_associated_vgw_topologyNzUMissing the required parameter `body` when calling `list_edx_associated_vgw_topology`r   r   r   r    zC/ListEDXAssociatedVGWTopology/2023-04-20/edx/post/application_json/r!   $ListEDXAssociatedVGWTopologyResponseTr#   r)   r4   s                  r   r-  z6EDXApi.list_edx_associated_vgw_topology_with_http_info  r  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_edx_available_vifvgw  # 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_edx_available_vifvgw(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListEDXAvailableVIFVGWRequest body: (required)
        :return: ListEDXAvailableVIFVGWResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   (list_edx_available_vifvgw_with_http_infor   s       r   list_edx_available_vifvgwz EDXApi.list_edx_available_vifvgw  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_edx_available_vifvgw  # 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_edx_available_vifvgw_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListEDXAvailableVIFVGWRequest body: (required)
        :return: ListEDXAvailableVIFVGWResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zKGot an unexpected keyword argument '%s' to method list_edx_available_vifvgwNzNMissing the required parameter `body` when calling `list_edx_available_vifvgw`r   r   r   r    z=/ListEDXAvailableVIFVGW/2023-04-20/edx/post/application_json/r!   ListEDXAvailableVIFVGWResponseTr#   r)   r4   s                  r   r2  z/EDXApi.list_edx_available_vifvgw_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_edx_bandwidth_pkg  # 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_edx_bandwidth_pkg(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListEDXBandwidthPkgRequest body: (required)
        :return: ListEDXBandwidthPkgResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   %list_edx_bandwidth_pkg_with_http_infor   s       r   list_edx_bandwidth_pkgzEDXApi.list_edx_bandwidth_pkg1  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_edx_bandwidth_pkg  # 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_edx_bandwidth_pkg_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListEDXBandwidthPkgRequest body: (required)
        :return: ListEDXBandwidthPkgResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method list_edx_bandwidth_pkgNzKMissing the required parameter `body` when calling `list_edx_bandwidth_pkg`r   r   r   r    z:/ListEDXBandwidthPkg/2023-04-20/edx/post/application_json/r!   ListEDXBandwidthPkgResponseTr#   r)   r4   s                  r   r7  z,EDXApi.list_edx_bandwidth_pkg_with_http_infoF  r  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_edx_peer_link  # 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_edx_peer_link(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListEDXPeerLinkRequest body: (required)
        :return: ListEDXPeerLinkResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !list_edx_peer_link_with_http_infor   s       r   list_edx_peer_linkzEDXApi.list_edx_peer_link  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_edx_peer_link  # 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_edx_peer_link_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListEDXPeerLinkRequest body: (required)
        :return: ListEDXPeerLinkResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method list_edx_peer_linkNzGMissing the required parameter `body` when calling `list_edx_peer_link`r   r   r   r    z6/ListEDXPeerLink/2023-04-20/edx/post/application_json/r!   ListEDXPeerLinkResponseTr#   r)   r4   s                  r   r<  z(EDXApi.list_edx_peer_link_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_route_aggregation  # 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_route_aggregation(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListRouteAggregationRequest body: (required)
        :return: ListRouteAggregationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   %list_route_aggregation_with_http_infor   s       r   list_route_aggregationzEDXApi.list_route_aggregation  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_route_aggregation  # 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_route_aggregation_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListRouteAggregationRequest body: (required)
        :return: ListRouteAggregationResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method list_route_aggregationNzKMissing the required parameter `body` when calling `list_route_aggregation`r   r   r   r    z;/ListRouteAggregation/2023-04-20/edx/post/application_json/r!   ListRouteAggregationResponseTr#   r)   r4   s                  r   rA  z,EDXApi.list_route_aggregation_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% **''I6#!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 )aE  list_topo_available_edx_bandwidth_pkg  # 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_topo_available_edx_bandwidth_pkg(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListTopoAvailableEDXBandwidthPkgRequest body: (required)
        :return: ListTopoAvailableEDXBandwidthPkgResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   4list_topo_available_edx_bandwidth_pkg_with_http_infor   s       r   %list_topo_available_edx_bandwidth_pkgz,EDXApi.list_topo_available_edx_bandwidth_pkgT  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 )aT  list_topo_available_edx_bandwidth_pkg  # 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_topo_available_edx_bandwidth_pkg_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListTopoAvailableEDXBandwidthPkgRequest body: (required)
        :return: ListTopoAvailableEDXBandwidthPkgResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zWGot an unexpected keyword argument '%s' to method list_topo_available_edx_bandwidth_pkgNzZMissing the required parameter `body` when calling `list_topo_available_edx_bandwidth_pkg`r   r   r   r    zG/ListTopoAvailableEDXBandwidthPkg/2023-04-20/edx/post/application_json/r!   (ListTopoAvailableEDXBandwidthPkgResponseTr#   r)   r4   s                  r   rG  z;EDXApi.list_topo_available_edx_bandwidth_pkg_with_http_infoi  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% **''UW]#!D'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_virtual_interface  # noqa: E501

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

        :param async_req bool
        :param ListVirtualInterfaceRequest body: (required)
        :return: ListVirtualInterfaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   %list_virtual_interface_with_http_infor   s       r   list_virtual_interfacezEDXApi.list_virtual_interface  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_virtual_interface  # noqa: E501

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

        :param async_req bool
        :param ListVirtualInterfaceRequest body: (required)
        :return: ListVirtualInterfaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method list_virtual_interfaceNzKMissing the required parameter `body` when calling `list_virtual_interface`r   r   r   r    z;/ListVirtualInterface/2023-04-20/edx/post/application_json/r!   ListVirtualInterfaceResponseTr#   r)   r4   s                  r   rL  z,EDXApi.list_virtual_interface_with_http_info  rE  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  modify_dxp_connection  # 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_dxp_connection(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyDXPConnectionRequest body: (required)
        :return: ModifyDXPConnectionResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $modify_dxp_connection_with_http_infor   s       r   modify_dxp_connectionzEDXApi.modify_dxp_connection  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_dxp_connection  # 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_dxp_connection_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyDXPConnectionRequest body: (required)
        :return: ModifyDXPConnectionResponse
                 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_dxp_connectionNzJMissing the required parameter `body` when calling `modify_dxp_connection`r   r   r   r    z:/ModifyDXPConnection/2023-04-20/edx/post/application_json/r!   ModifyDXPConnectionResponseTr#   r)   r4   s                  r   rQ  z+EDXApi.modify_dxp_connection_with_http_info+  r?   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  modify_dxp_instance  # 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_dxp_instance(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyDXPInstanceRequest body: (required)
        :return: ModifyDXPInstanceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "modify_dxp_instance_with_http_infor   s       r   modify_dxp_instancezEDXApi.modify_dxp_instancew  ra   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_dxp_instance  # 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_dxp_instance_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyDXPInstanceRequest body: (required)
        :return: ModifyDXPInstanceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zEGot an unexpected keyword argument '%s' to method modify_dxp_instanceNzHMissing the required parameter `body` when calling `modify_dxp_instance`r   r   r   r    z8/ModifyDXPInstance/2023-04-20/edx/post/application_json/r!   ModifyDXPInstanceResponseTr#   r)   r4   s                  r   rV  z)EDXApi.modify_dxp_instance_with_http_info  rd   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  modify_edx_attribute  # 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_edx_attribute(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyEDXAttributeRequest body: (required)
        :return: ModifyEDXAttributeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #modify_edx_attribute_with_http_infor   s       r   modify_edx_attributezEDXApi.modify_edx_attribute  rv   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_edx_attribute  # 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_edx_attribute_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyEDXAttributeRequest body: (required)
        :return: ModifyEDXAttributeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method modify_edx_attributeNzIMissing the required parameter `body` when calling `modify_edx_attribute`r   r   r   r    z9/ModifyEDXAttribute/2023-04-20/edx/post/application_json/r!   ModifyEDXAttributeResponseTr#   r)   r4   s                  r   r[  z*EDXApi.modify_edx_attribute_with_http_info  s    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% **''G#!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  modify_edx_bandwidth_pkg  # 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_edx_bandwidth_pkg(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyEDXBandwidthPkgRequest body: (required)
        :return: ModifyEDXBandwidthPkgResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'modify_edx_bandwidth_pkg_with_http_infor   s       r   modify_edx_bandwidth_pkgzEDXApi.modify_edx_bandwidth_pkg9  ro   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_edx_bandwidth_pkg  # 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_edx_bandwidth_pkg_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyEDXBandwidthPkgRequest body: (required)
        :return: ModifyEDXBandwidthPkgResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zJGot an unexpected keyword argument '%s' to method modify_edx_bandwidth_pkgNzMMissing the required parameter `body` when calling `modify_edx_bandwidth_pkg`r   r   r   r    z</ModifyEDXBandwidthPkg/2023-04-20/edx/post/application_json/r!   ModifyEDXBandwidthPkgResponseTr#   r)   r4   s                  r   r`  z.EDXApi.modify_edx_bandwidth_pkg_with_http_infoN  rr   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a=  modify_route_aggregation_attribute  # 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_route_aggregation_attribute(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyRouteAggregationAttributeRequest body: (required)
        :return: ModifyRouteAggregationAttributeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   1modify_route_aggregation_attribute_with_http_infor   s       r   "modify_route_aggregation_attributez)EDXApi.modify_route_aggregation_attribute  rO   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aL  modify_route_aggregation_attribute  # 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_route_aggregation_attribute_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyRouteAggregationAttributeRequest body: (required)
        :return: ModifyRouteAggregationAttributeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zTGot an unexpected keyword argument '%s' to method modify_route_aggregation_attributeNzWMissing the required parameter `body` when calling `modify_route_aggregation_attribute`r   r   r   r    zF/ModifyRouteAggregationAttribute/2023-04-20/edx/post/application_json/r!   'ModifyRouteAggregationAttributeResponseTr#   r)   r4   s                  r   re  z8EDXApi.modify_route_aggregation_attribute_with_http_info      X
+&&&2333,---,---fX&677 	 	HC*$$DFIJ   F3KK8?1 	xvV7K7K7=f~7MvwwwV .K"&/"F"F #" #"h )-(R(R )" )"n% **''TV\#!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=  modify_virtual_interface_attribute  # 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_virtual_interface_attribute(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyVirtualInterfaceAttributeRequest body: (required)
        :return: ModifyVirtualInterfaceAttributeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   1modify_virtual_interface_attribute_with_http_infor   s       r   "modify_virtual_interface_attributez)EDXApi.modify_virtual_interface_attribute  rO   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )aL  modify_virtual_interface_attribute  # 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_virtual_interface_attribute_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyVirtualInterfaceAttributeRequest body: (required)
        :return: ModifyVirtualInterfaceAttributeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zTGot an unexpected keyword argument '%s' to method modify_virtual_interface_attributeNzWMissing the required parameter `body` when calling `modify_virtual_interface_attribute`r   r   r   r    zF/ModifyVirtualInterfaceAttribute/2023-04-20/edx/post/application_json/r!   'ModifyVirtualInterfaceAttributeResponseTr#   r)   r4   s                  r   rk  z8EDXApi.modify_virtual_interface_attribute_with_http_info  ri  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a%  modify_virtual_interface_bfd  # 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_virtual_interface_bfd(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyVirtualInterfaceBFDRequest body: (required)
        :return: ModifyVirtualInterfaceBFDResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   +modify_virtual_interface_bfd_with_http_infor   s       r   modify_virtual_interface_bfdz#EDXApi.modify_virtual_interface_bfd\  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 )a4  modify_virtual_interface_bfd  # 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_virtual_interface_bfd_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyVirtualInterfaceBFDRequest body: (required)
        :return: ModifyVirtualInterfaceBFDResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zNGot an unexpected keyword argument '%s' to method modify_virtual_interface_bfdNzQMissing the required parameter `body` when calling `modify_virtual_interface_bfd`r   r   r   r    z@/ModifyVirtualInterfaceBFD/2023-04-20/edx/post/application_json/r!   !ModifyVirtualInterfaceBFDResponseTr#   r)   r4   s                  r   rp  z2EDXApi.modify_virtual_interface_bfd_with_http_infoq  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a;  reject_cross_account_vif_authority  # noqa: E501

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

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

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

        :param async_req bool
        :param RejectCrossAccountVIFAuthorityRequest body: (required)
        :return: RejectCrossAccountVIFAuthorityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zTGot an unexpected keyword argument '%s' to method reject_cross_account_vif_authorityNzWMissing the required parameter `body` when calling `reject_cross_account_vif_authority`r   r   r   r    zE/RejectCrossAccountVIFAuthority/2023-04-20/edx/post/application_json/r!   &RejectCrossAccountVIFAuthorityResponseTr#   r)   r4   s                  r   ru  z8EDXApi.reject_cross_account_vif_authority_with_http_info  rR   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  resume_dxp_instance  # noqa: E501

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

        :param async_req bool
        :param ResumeDXPInstanceRequest body: (required)
        :return: ResumeDXPInstanceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "resume_dxp_instance_with_http_infor   s       r   resume_dxp_instancezEDXApi.resume_dxp_instance  ra   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  resume_dxp_instance  # noqa: E501

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

        :param async_req bool
        :param ResumeDXPInstanceRequest body: (required)
        :return: ResumeDXPInstanceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zEGot an unexpected keyword argument '%s' to method resume_dxp_instanceNzHMissing the required parameter `body` when calling `resume_dxp_instance`r   r   r   r    z8/ResumeDXPInstance/2023-04-20/edx/post/application_json/r!   ResumeDXPInstanceResponseTr#   r)   r4   s                  r   rz  z)EDXApi.resume_dxp_instance_with_http_info3  rd   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a;  revoke_cross_account_vif_authority  # noqa: E501

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

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

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

        :param async_req bool
        :param RevokeCrossAccountVIFAuthorityRequest body: (required)
        :return: RevokeCrossAccountVIFAuthorityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zTGot an unexpected keyword argument '%s' to method revoke_cross_account_vif_authorityNzWMissing the required parameter `body` when calling `revoke_cross_account_vif_authority`r   r   r   r    zE/RevokeCrossAccountVIFAuthority/2023-04-20/edx/post/application_json/r!   &RevokeCrossAccountVIFAuthorityResponseTr#   r)   r4   s                  r   r  z8EDXApi.revoke_cross_account_vif_authority_with_http_info  rR   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a#  sign_construction_completed  # noqa: E501

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

        :param async_req bool
        :param SignConstructionCompletedRequest body: (required)
        :return: SignConstructionCompletedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   *sign_construction_completed_with_http_infor   s       r   sign_construction_completedz"EDXApi.sign_construction_completed  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 )a2  sign_construction_completed  # noqa: E501

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

        :param async_req bool
        :param SignConstructionCompletedRequest body: (required)
        :return: SignConstructionCompletedResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zMGot an unexpected keyword argument '%s' to method sign_construction_completedNzPMissing the required parameter `body` when calling `sign_construction_completed`r   r   r   r    z@/SignConstructionCompleted/2023-04-20/edx/post/application_json/r!   !SignConstructionCompletedResponseTr#   r)   r4   s                  r   r  z1EDXApi.sign_construction_completed_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$=?BC   F3KK8?1 	qvV7K7K7=f~7MopppV .K"&/"F"F #" #"h )-(R(R )" )"n% **''NPV#!='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  stop_dxp_instance  # noqa: E501

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

        :param async_req bool
        :param StopDXPInstanceRequest body: (required)
        :return: StopDXPInstanceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r    stop_dxp_instance_with_http_infor   s       r   stop_dxp_instancezEDXApi.stop_dxp_instanceA  s]     ,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
  stop_dxp_instance  # noqa: E501

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

        :param async_req bool
        :param StopDXPInstanceRequest body: (required)
        :return: StopDXPInstanceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zCGot an unexpected keyword argument '%s' to method stop_dxp_instanceNzFMissing the required parameter `body` when calling `stop_dxp_instance`r   r   r   r    z6/StopDXPInstance/2023-04-20/edx/post/application_json/r!   StopDXPInstanceResponseTr#   r)   r4   s                  r   r  z'EDXApi.stop_dxp_instance_with_http_infoV  s    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% **''Df#!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  update_edx_link_bandwidth  # noqa: E501

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

        :param async_req bool
        :param UpdateEDXLinkBandwidthRequest body: (required)
        :return: UpdateEDXLinkBandwidthResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   (update_edx_link_bandwidth_with_http_infor   s       r   update_edx_link_bandwidthz EDXApi.update_edx_link_bandwidth  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(  update_edx_link_bandwidth  # noqa: E501

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

        :param async_req bool
        :param UpdateEDXLinkBandwidthRequest body: (required)
        :return: UpdateEDXLinkBandwidthResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zKGot an unexpected keyword argument '%s' to method update_edx_link_bandwidthNzNMissing the required parameter `body` when calling `update_edx_link_bandwidth`r   r   r   r    z=/UpdateEDXLinkBandwidth/2023-04-20/edx/post/application_json/r!   UpdateEDXLinkBandwidthResponseTr#   r)   r4   s                  r   r  z/EDXApi.update_edx_link_bandwidth_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a)  update_edxvgw_topo_coordinate  # noqa: E501

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

        :param async_req bool
        :param UpdateEDXVGWTopoCoordinateRequest body: (required)
        :return: UpdateEDXVGWTopoCoordinateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   ,update_edxvgw_topo_coordinate_with_http_infor   s       r   update_edxvgw_topo_coordinatez$EDXApi.update_edxvgw_topo_coordinate  s]     ,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  update_edxvgw_topo_coordinate  # noqa: E501

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

        :param async_req bool
        :param UpdateEDXVGWTopoCoordinateRequest body: (required)
        :return: UpdateEDXVGWTopoCoordinateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zOGot an unexpected keyword argument '%s' to method update_edxvgw_topo_coordinateNzRMissing the required parameter `body` when calling `update_edxvgw_topo_coordinate`r   r   r   r    zA/UpdateEDXVGWTopoCoordinate/2023-04-20/edx/post/application_json/r!   "UpdateEDXVGWTopoCoordinateResponseTr#   r)   r4   s                  r   r  z3EDXApi.update_edxvgw_topo_coordinate_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% **''OQW#!>'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  upload_dxp_license  # 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_dxp_license(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param UploadDXPLicenseRequest body: (required)
        :return: UploadDXPLicenseResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !upload_dxp_license_with_http_infor   s       r   upload_dxp_licensezEDXApi.upload_dxp_licensed  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_dxp_license  # 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_dxp_license_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param UploadDXPLicenseRequest body: (required)
        :return: UploadDXPLicenseResponse
                 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_dxp_licenseNzGMissing the required parameter `body` when calling `upload_dxp_license`r   r   r   r    z7/UploadDXPLicense/2023-04-20/edx/post/application_json/r!   UploadDXPLicenseResponseTr#   r)   r4   s                  r   r  z(EDXApi.upload_dxp_license_with_http_infoy  r   r   r   )__name__
__module____qualname____doc__r   r   r   rB   rA   rI   rH   rN   rM   rU   rT   rZ   rY   r`   r_   rg   rf   rn   rm   ru   rt   r|   r{   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r  r  r  r  r  r  r  r  r$  r#  r)  r(  r.  r-  r3  r2  r8  r7  r=  r<  rB  rA  rH  rG  rM  rL  rR  rQ  rW  rV  r\  r[  ra  r`  rf  re  rl  rk  rq  rp  rv  ru  r{  rz  r  r  r  r  r  r  r  r  r  r  r  r   r   r   r   r      s        % % % %
  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3 J3 J3r   r   )r  
__future__r   rer,   r   objectr   r  r   r   <module>r     s     ' & & & & & 				 


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