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

    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                   n   e Zd ZdZddZd Zd Zd Zd Zd Z	d	 Z
d
 Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Z d  Z!d! Z"d" Z#d# Z$d$ Z%d% Z&d& Z'd' Z(d( Z)d) Z*d* Z+d+ Z,d, Z-d- Z.d. Z/d/ Z0d0 Z1d1 Z2d2 Z3d3 Z4d4 Z5d5 Z6d6 Z7d7 Z8d8 Z9d9 Z:d: Z;d; Z<d< Z=d= Z>d> Z?d? Z@d@ ZAdA ZBdB ZCdC ZDdD ZEdE ZFdF ZGdG ZHdH ZIdI ZJdJ ZKdK ZLdL ZMdM ZNdN ZOdO ZPdP ZQdQ ZRdR ZSdS ZTdT ZUdU ZVdV ZWdW ZXdX ZYdY ZZdZ Z[d[ Z\d\ Z]d] Z^d^ Z_d_ Z`d` Zada Zbdb Zcdc Zddd Zede Zfdf Zgdg Zhdh Zidi Zjdj Zkdk Zldl Zmdm Zndn Zodo Zpdp Zqdq Zrdr Zsds Ztdt Zudu Zvdv Zwdw Zxdx Zydy Zzdz Z{d{ Z|d| Z}d} Z~d~ Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd ZdS )ROCKETMQApizNOTE: 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     o/root/.openclaw/workspace/.venvs/ark-sdk/lib/python3.11/site-packages/volcenginesdkrocketmq/api/rocketmq_api.py__init__zROCKETMQApi.__init__   s!    *466J$    c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  add_pl_whitelist  # 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_pl_whitelist(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param AddPLWhitelistRequest body: (required)
        :return: AddPLWhitelistResponse
                 If the method is called asynchronously,
                 returns the request thread.
        T_return_http_data_only	async_req)getadd_pl_whitelist_with_http_infor   bodykwargsdatas       r   add_pl_whitelistzROCKETMQApi.add_pl_whitelist$   ]     ,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  add_pl_whitelist  # 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_pl_whitelist_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param AddPLWhitelistRequest body: (required)
        :return: AddPLWhitelistResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   _preload_content_request_timeoutr   zBGot an unexpected keyword argument '%s' to method add_pl_whitelistNzEMissing the required parameter `body` when calling `add_pl_whitelist`application/jsonAcceptContent-TypevolcengineSignz:/AddPLWhitelist/2023-01-01/rocketmq/post/application_json/POSTAddPLWhitelistResponseT
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+ROCKETMQApi.add_pl_whitelist_with_http_info9   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% **''H&#!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  add_tags_to_resource  # noqa: E501

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

        :param async_req bool
        :param AddTagsToResourceRequest body: (required)
        :return: AddTagsToResourceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #add_tags_to_resource_with_http_infor   s       r   add_tags_to_resourcez ROCKETMQApi.add_tags_to_resource   ]     ,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  add_tags_to_resource  # noqa: E501

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

        :param async_req bool
        :param AddTagsToResourceRequest body: (required)
        :return: AddTagsToResourceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method add_tags_to_resourceNzIMissing the required parameter `body` when calling `add_tags_to_resource`r   r   r   r    z=/AddTagsToResource/2023-01-01/rocketmq/post/application_json/r!   AddTagsToResourceResponseTr#   r)   r4   s                  r   r@   z/ROCKETMQApi.add_tags_to_resource_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% **''KV#!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  associate_allow_list  # noqa: E501

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

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

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

        :param async_req bool
        :param AssociateAllowListRequest body: (required)
        :return: AssociateAllowListResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method associate_allow_listNzIMissing the required parameter `body` when calling `associate_allow_list`r   r   r   r    z>/AssociateAllowList/2023-01-01/rocketmq/post/application_json/r!   AssociateAllowListResponseTr#   r)   r4   s                  r   rF   z/ROCKETMQApi.associate_allow_list_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% **''Lf#!6'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_allow_list  # 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_allow_list(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateAllowListRequest body: (required)
        :return: CreateAllowListResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r    create_allow_list_with_http_infor   s       r   create_allow_listzROCKETMQApi.create_allow_listG  ]     ,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
  create_allow_list  # 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_allow_list_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateAllowListRequest body: (required)
        :return: CreateAllowListResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zCGot an unexpected keyword argument '%s' to method create_allow_listNzFMissing the required parameter `body` when calling `create_allow_list`r   r   r   r    z;/CreateAllowList/2023-01-01/rocketmq/post/application_json/r!   CreateAllowListResponseTr#   r)   r4   s                  r   rL   z,ROCKETMQApi.create_allow_list_with_http_info\      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% **''I6#!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  create_group  # noqa: E501

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

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

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

        :param async_req bool
        :param CreateGroupRequest body: (required)
        :return: CreateGroupResponse
                 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_groupNzAMissing the required parameter `body` when calling `create_group`r   r   r   r    z7/CreateGroup/2023-01-01/rocketmq/post/application_json/r!   CreateGroupResponseTr#   r)   r4   s                  r   rS   z'ROCKETMQApi.create_group_with_http_info      X
+&&&2333,---,---fX&677 	 	HC*$$.034   F3KK8?1 	bvV7K7K7=f~7M`aaaV .K"&/"F"F #" #"h )-(R(R )" )"n% **''Ev#!/'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_group_async  # 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_group_async(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateGroupAsyncRequest body: (required)
        :return: CreateGroupAsyncResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !create_group_async_with_http_infor   s       r   create_group_asynczROCKETMQApi.create_group_async	  ]     ,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  create_group_async  # 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_group_async_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateGroupAsyncRequest body: (required)
        :return: CreateGroupAsyncResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method create_group_asyncNzGMissing the required parameter `body` when calling `create_group_async`r   r   r   r    z</CreateGroupAsync/2023-01-01/rocketmq/post/application_json/r!   CreateGroupAsyncResponseTr#   r)   r4   s                  r   rZ   z-ROCKETMQApi.create_group_async_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% **''JF#!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  create_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_instance(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateInstanceRequest body: (required)
        :return: CreateInstanceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   create_instance_with_http_infor   s       r   create_instancezROCKETMQApi.create_instancej  ]     ,0'(::k"" 	646tFFvFFF8T8HHHHTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  create_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_instance_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateInstanceRequest body: (required)
        :return: CreateInstanceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zAGot an unexpected keyword argument '%s' to method create_instanceNzDMissing the required parameter `body` when calling `create_instance`r   r   r   r    z:/CreateInstance/2023-01-01/rocketmq/post/application_json/r!   CreateInstanceResponseTr#   r)   r4   s                  r   ra   z*ROCKETMQApi.create_instance_with_http_info      X
+&&&2333,---,---fX&677 	 	HC*$$1367   F3KK8?1 	evV7K7K7=f~7McdddV .K"&/"F"F #" #"h )-(R(R )" )"n% **''H&#!2'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_private_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_private_link(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreatePrivateLinkRequest body: (required)
        :return: CreatePrivateLinkResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "create_private_link_with_http_infor   s       r   create_private_linkzROCKETMQApi.create_private_link  ]     ,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_private_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_private_link_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreatePrivateLinkRequest body: (required)
        :return: CreatePrivateLinkResponse
                 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_private_linkNzHMissing the required parameter `body` when calling `create_private_link`r   r   r   r    z=/CreatePrivateLink/2023-01-01/rocketmq/post/application_json/r!   CreatePrivateLinkResponseTr#   r)   r4   s                  r   rh   z.ROCKETMQApi.create_private_link_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% **''KV#!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_public_address  # 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_public_address(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreatePublicAddressRequest body: (required)
        :return: CreatePublicAddressResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $create_public_address_with_http_infor   s       r   create_public_addressz!ROCKETMQApi.create_public_address,  ]     ,0'(::k"" 	<4<TLLVLLL>T>tNNvNNTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  create_public_address  # 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_public_address_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreatePublicAddressRequest body: (required)
        :return: CreatePublicAddressResponse
                 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_public_addressNzJMissing the required parameter `body` when calling `create_public_address`r   r   r   r    z?/CreatePublicAddress/2023-01-01/rocketmq/post/application_json/r!   CreatePublicAddressResponseTr#   r)   r4   s                  r   ro   z0ROCKETMQApi.create_public_address_with_http_infoA      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% **''Mv#!7'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_topic  # noqa: E501

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

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

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

        :param async_req bool
        :param CreateTopicRequest body: (required)
        :return: CreateTopicResponse
                 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_topicNzAMissing the required parameter `body` when calling `create_topic`r   r   r   r    z7/CreateTopic/2023-01-01/rocketmq/post/application_json/r!   CreateTopicResponseTr#   r)   r4   s                  r   rv   z'ROCKETMQApi.create_topic_with_http_info  rX   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_topic_async  # 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_topic_async(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateTopicAsyncRequest body: (required)
        :return: CreateTopicAsyncResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !create_topic_async_with_http_infor   s       r   create_topic_asynczROCKETMQApi.create_topic_async  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_topic_async  # 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_topic_async_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateTopicAsyncRequest body: (required)
        :return: CreateTopicAsyncResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method create_topic_asyncNzGMissing the required parameter `body` when calling `create_topic_async`r   r   r   r    z</CreateTopicAsync/2023-01-01/rocketmq/post/application_json/r!   CreateTopicAsyncResponseTr#   r)   r4   s                  r   r{   z-ROCKETMQApi.create_topic_async_with_http_info  r_   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_access_key  # noqa: E501

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

        :param async_req bool
        :param DeleteAccessKeyRequest body: (required)
        :return: DeleteAccessKeyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r    delete_access_key_with_http_infor   s       r   delete_access_keyzROCKETMQApi.delete_access_keyO  rN   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_access_key  # noqa: E501

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

        :param async_req bool
        :param DeleteAccessKeyRequest body: (required)
        :return: DeleteAccessKeyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zCGot an unexpected keyword argument '%s' to method delete_access_keyNzFMissing the required parameter `body` when calling `delete_access_key`r   r   r   r    z;/DeleteAccessKey/2023-01-01/rocketmq/post/application_json/r!   DeleteAccessKeyResponseTr#   r)   r4   s                  r   r   z,ROCKETMQApi.delete_access_key_with_http_infod  rQ   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_allow_list  # 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_allow_list(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteAllowListRequest body: (required)
        :return: DeleteAllowListResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r    delete_allow_list_with_http_infor   s       r   delete_allow_listzROCKETMQApi.delete_allow_list  rN   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_allow_list  # 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_allow_list_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteAllowListRequest body: (required)
        :return: DeleteAllowListResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zCGot an unexpected keyword argument '%s' to method delete_allow_listNzFMissing the required parameter `body` when calling `delete_allow_list`r   r   r   r    z;/DeleteAllowList/2023-01-01/rocketmq/post/application_json/r!   DeleteAllowListResponseTr#   r)   r4   s                  r   r   z,ROCKETMQApi.delete_allow_list_with_http_info  rQ   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_group  # noqa: E501

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

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

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

        :param async_req bool
        :param DeleteGroupRequest body: (required)
        :return: DeleteGroupResponse
                 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_groupNzAMissing the required parameter `body` when calling `delete_group`r   r   r   r    z7/DeleteGroup/2023-01-01/rocketmq/post/application_json/r!   DeleteGroupResponseTr#   r)   r4   s                  r   r   z'ROCKETMQApi.delete_group_with_http_info&  rX   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_group_async  # 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_group_async(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteGroupAsyncRequest body: (required)
        :return: DeleteGroupAsyncResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !delete_group_async_with_http_infor   s       r   delete_group_asynczROCKETMQApi.delete_group_asyncr  r\   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  delete_group_async  # 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_group_async_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteGroupAsyncRequest body: (required)
        :return: DeleteGroupAsyncResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method delete_group_asyncNzGMissing the required parameter `body` when calling `delete_group_async`r   r   r   r    z</DeleteGroupAsync/2023-01-01/rocketmq/post/application_json/r!   DeleteGroupAsyncResponseTr#   r)   r4   s                  r   r   z-ROCKETMQApi.delete_group_async_with_http_info  r_   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_groups  # noqa: E501

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

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

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

        :param async_req bool
        :param DeleteGroupsRequest body: (required)
        :return: DeleteGroupsResponse
                 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_groupsNzBMissing the required parameter `body` when calling `delete_groups`r   r   r   r    z8/DeleteGroups/2023-01-01/rocketmq/post/application_json/r!   DeleteGroupsResponseTr#   r)   r4   s                  r   r   z(ROCKETMQApi.delete_groups_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$/145   F3KK8?1 	cvV7K7K7=f~7MabbbV .K"&/"F"F #" #"h )-(R(R )" )"n% **''F#!0'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_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_instance(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteInstanceRequest body: (required)
        :return: DeleteInstanceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   delete_instance_with_http_infor   s       r   delete_instancezROCKETMQApi.delete_instance4  rc   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  delete_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_instance_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteInstanceRequest body: (required)
        :return: DeleteInstanceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zAGot an unexpected keyword argument '%s' to method delete_instanceNzDMissing the required parameter `body` when calling `delete_instance`r   r   r   r    z:/DeleteInstance/2023-01-01/rocketmq/post/application_json/r!   DeleteInstanceResponseTr#   r)   r4   s                  r   r   z*ROCKETMQApi.delete_instance_with_http_infoI  rf   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_private_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_private_link(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeletePrivateLinkRequest body: (required)
        :return: DeletePrivateLinkResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "delete_private_link_with_http_infor   s       r   delete_private_linkzROCKETMQApi.delete_private_link  rj   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  delete_private_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_private_link_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeletePrivateLinkRequest body: (required)
        :return: DeletePrivateLinkResponse
                 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_private_linkNzHMissing the required parameter `body` when calling `delete_private_link`r   r   r   r    z=/DeletePrivateLink/2023-01-01/rocketmq/post/application_json/r!   DeletePrivateLinkResponseTr#   r)   r4   s                  r   r   z.ROCKETMQApi.delete_private_link_with_http_info  rm   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_public_address  # 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_public_address(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeletePublicAddressRequest body: (required)
        :return: DeletePublicAddressResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $delete_public_address_with_http_infor   s       r   delete_public_addressz!ROCKETMQApi.delete_public_address  rq   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_public_address  # 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_public_address_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeletePublicAddressRequest body: (required)
        :return: DeletePublicAddressResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method delete_public_addressNzJMissing the required parameter `body` when calling `delete_public_address`r   r   r   r    z?/DeletePublicAddress/2023-01-01/rocketmq/post/application_json/r!   DeletePublicAddressResponseTr#   r)   r4   s                  r   r   z0ROCKETMQApi.delete_public_address_with_http_info  rt   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_topic  # noqa: E501

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

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

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

        :param async_req bool
        :param DeleteTopicRequest body: (required)
        :return: DeleteTopicResponse
                 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_topicNzAMissing the required parameter `body` when calling `delete_topic`r   r   r   r    z7/DeleteTopic/2023-01-01/rocketmq/post/application_json/r!   DeleteTopicResponseTr#   r)   r4   s                  r   r   z'ROCKETMQApi.delete_topic_with_http_infol  rX   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_topic_async  # 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_topic_async(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteTopicAsyncRequest body: (required)
        :return: DeleteTopicAsyncResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !delete_topic_async_with_http_infor   s       r   delete_topic_asynczROCKETMQApi.delete_topic_async  r\   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  delete_topic_async  # 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_topic_async_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteTopicAsyncRequest body: (required)
        :return: DeleteTopicAsyncResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method delete_topic_asyncNzGMissing the required parameter `body` when calling `delete_topic_async`r   r   r   r    z</DeleteTopicAsync/2023-01-01/rocketmq/post/application_json/r!   DeleteTopicAsyncResponseTr#   r)   r4   s                  r   r   z-ROCKETMQApi.delete_topic_async_with_http_info  r_   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_access_key_detail  # 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_access_key_detail(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeAccessKeyDetailRequest body: (required)
        :return: DescribeAccessKeyDetailResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )describe_access_key_detail_with_http_infor   s       r   describe_access_key_detailz&ROCKETMQApi.describe_access_key_detail  ]     ,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_access_key_detail  # 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_access_key_detail_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeAccessKeyDetailRequest body: (required)
        :return: DescribeAccessKeyDetailResponse
                 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_access_key_detailNzOMissing the required parameter `body` when calling `describe_access_key_detail`r   r   r   r    zC/DescribeAccessKeyDetail/2023-01-01/rocketmq/post/application_json/r!   DescribeAccessKeyDetailResponseTr#   r)   r4   s                  r   r   z5ROCKETMQApi.describe_access_key_detail_with_http_info.      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% **''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  describe_access_keys  # 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_access_keys(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeAccessKeysRequest body: (required)
        :return: DescribeAccessKeysResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #describe_access_keys_with_http_infor   s       r   describe_access_keysz ROCKETMQApi.describe_access_keysz  rB   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  describe_access_keys  # 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_access_keys_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeAccessKeysRequest body: (required)
        :return: DescribeAccessKeysResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method describe_access_keysNzIMissing the required parameter `body` when calling `describe_access_keys`r   r   r   r    z>/DescribeAccessKeys/2023-01-01/rocketmq/post/application_json/r!   DescribeAccessKeysResponseTr#   r)   r4   s                  r   r   z/ROCKETMQApi.describe_access_keys_with_http_info  rJ   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_allow_list_detail  # 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_allow_list_detail(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeAllowListDetailRequest body: (required)
        :return: DescribeAllowListDetailResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )describe_allow_list_detail_with_http_infor   s       r   describe_allow_list_detailz&ROCKETMQApi.describe_allow_list_detail  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a,  describe_allow_list_detail  # 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_allow_list_detail_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeAllowListDetailRequest body: (required)
        :return: DescribeAllowListDetailResponse
                 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_allow_list_detailNzOMissing the required parameter `body` when calling `describe_allow_list_detail`r   r   r   r    zC/DescribeAllowListDetail/2023-01-01/rocketmq/post/application_json/r!   DescribeAllowListDetailResponseTr#   r)   r4   s                  r   r   z5ROCKETMQApi.describe_allow_list_detail_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_allow_lists  # 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_allow_lists(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeAllowListsRequest body: (required)
        :return: DescribeAllowListsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #describe_allow_lists_with_http_infor   s       r   describe_allow_listsz ROCKETMQApi.describe_allow_lists<	  rB   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  describe_allow_lists  # 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_allow_lists_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeAllowListsRequest body: (required)
        :return: DescribeAllowListsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method describe_allow_listsNzIMissing the required parameter `body` when calling `describe_allow_lists`r   r   r   r    z>/DescribeAllowLists/2023-01-01/rocketmq/post/application_json/r!   DescribeAllowListsResponseTr#   r)   r4   s                  r   r   z/ROCKETMQApi.describe_allow_lists_with_http_infoQ	  rJ   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a#  describe_availability_zones  # noqa: E501

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

        :param async_req bool
        :param DescribeAvailabilityZonesRequest body: (required)
        :return: DescribeAvailabilityZonesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   *describe_availability_zones_with_http_infor   s       r   describe_availability_zonesz'ROCKETMQApi.describe_availability_zones	  ]     ,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 )a2  describe_availability_zones  # noqa: E501

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

        :param async_req bool
        :param DescribeAvailabilityZonesRequest body: (required)
        :return: DescribeAvailabilityZonesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zMGot an unexpected keyword argument '%s' to method describe_availability_zonesNzPMissing the required parameter `body` when calling `describe_availability_zones`r   r   r   r    zE/DescribeAvailabilityZones/2023-01-01/rocketmq/post/application_json/r!   !DescribeAvailabilityZonesResponseTr#   r)   r4   s                  r   r   z6ROCKETMQApi.describe_availability_zones_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% **''SU[#!='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_consumed_clients  # 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_consumed_clients(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeConsumedClientsRequest body: (required)
        :return: DescribeConsumedClientsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   (describe_consumed_clients_with_http_infor   s       r   describe_consumed_clientsz%ROCKETMQApi.describe_consumed_clients	  ]     ,0'(::k"" 	@4@PPPPPBTB4RR6RRTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a*  describe_consumed_clients  # 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_consumed_clients_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeConsumedClientsRequest body: (required)
        :return: DescribeConsumedClientsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zKGot an unexpected keyword argument '%s' to method describe_consumed_clientsNzNMissing the required parameter `body` when calling `describe_consumed_clients`r   r   r   r    zC/DescribeConsumedClients/2023-01-01/rocketmq/post/application_json/r!   DescribeConsumedClientsResponseTr#   r)   r4   s                  r   r   z4ROCKETMQApi.describe_consumed_clients_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% **''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-  describe_consumed_topic_detail  # 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_consumed_topic_detail(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeConsumedTopicDetailRequest body: (required)
        :return: DescribeConsumedTopicDetailResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   -describe_consumed_topic_detail_with_http_infor   s       r   describe_consumed_topic_detailz*ROCKETMQApi.describe_consumed_topic_detail_
  ^     ,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_consumed_topic_detail  # 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_consumed_topic_detail_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeConsumedTopicDetailRequest body: (required)
        :return: DescribeConsumedTopicDetailResponse
                 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_consumed_topic_detailNzSMissing the required parameter `body` when calling `describe_consumed_topic_detail`r   r   r   r    zG/DescribeConsumedTopicDetail/2023-01-01/rocketmq/post/application_json/r!   #DescribeConsumedTopicDetailResponseTr#   r)   r4   s                  r   r   z9ROCKETMQApi.describe_consumed_topic_detail_with_http_infot
      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% **''UW]#!?'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_consumed_topics  # 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_consumed_topics(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeConsumedTopicsRequest body: (required)
        :return: DescribeConsumedTopicsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'describe_consumed_topics_with_http_infor   s       r   describe_consumed_topicsz$ROCKETMQApi.describe_consumed_topics
  ]     ,0'(::k"" 	?4?OOOOOATA$QQ&QQTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a&  describe_consumed_topics  # 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_consumed_topics_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeConsumedTopicsRequest body: (required)
        :return: DescribeConsumedTopicsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zJGot an unexpected keyword argument '%s' to method describe_consumed_topicsNzMMissing the required parameter `body` when calling `describe_consumed_topics`r   r   r   r    zB/DescribeConsumedTopics/2023-01-01/rocketmq/post/application_json/r!   DescribeConsumedTopicsResponseTr#   r)   r4   s                  r   r   z3ROCKETMQApi.describe_consumed_topics_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% **''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_groups  # noqa: E501

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

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

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

        :param async_req bool
        :param DescribeGroupsRequest body: (required)
        :return: DescribeGroupsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zAGot an unexpected keyword argument '%s' to method describe_groupsNzDMissing the required parameter `body` when calling `describe_groups`r   r   r   r    z:/DescribeGroups/2023-01-01/rocketmq/post/application_json/r!   DescribeGroupsResponseTr#   r)   r4   s                  r   r   z*ROCKETMQApi.describe_groups_with_http_info6  rf   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_groups_detail  # 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_groups_detail(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeGroupsDetailRequest body: (required)
        :return: DescribeGroupsDetailResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   %describe_groups_detail_with_http_infor   s       r   describe_groups_detailz"ROCKETMQApi.describe_groups_detail  ]     ,0'(::k"" 	=4=dMMfMMM?T?OOOOTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  describe_groups_detail  # 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_groups_detail_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeGroupsDetailRequest body: (required)
        :return: DescribeGroupsDetailResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method describe_groups_detailNzKMissing the required parameter `body` when calling `describe_groups_detail`r   r   r   r    z@/DescribeGroupsDetail/2023-01-01/rocketmq/post/application_json/r!   DescribeGroupsDetailResponseTr#   r)   r4   s                  r   r   z1ROCKETMQApi.describe_groups_detail_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% **''NPV#!8'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_instance_detail  # 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_instance_detail(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeInstanceDetailRequest body: (required)
        :return: DescribeInstanceDetailResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'describe_instance_detail_with_http_infor   s       r   describe_instance_detailz$ROCKETMQApi.describe_instance_detail  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a&  describe_instance_detail  # 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_instance_detail_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeInstanceDetailRequest body: (required)
        :return: DescribeInstanceDetailResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zJGot an unexpected keyword argument '%s' to method describe_instance_detailNzMMissing the required parameter `body` when calling `describe_instance_detail`r   r   r   r    zB/DescribeInstanceDetail/2023-01-01/rocketmq/post/application_json/r!   DescribeInstanceDetailResponseTr#   r)   r4   s                  r   r   z3ROCKETMQApi.describe_instance_detail_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_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.describe_instances(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeInstancesRequest body: (required)
        :return: DescribeInstancesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !describe_instances_with_http_infor   s       r   describe_instanceszROCKETMQApi.describe_instancesD  r\   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  describe_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.describe_instances_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeInstancesRequest body: (required)
        :return: DescribeInstancesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method describe_instancesNzGMissing the required parameter `body` when calling `describe_instances`r   r   r   r    z=/DescribeInstances/2023-01-01/rocketmq/post/application_json/r!   DescribeInstancesResponseTr#   r)   r4   s                  r   r   z-ROCKETMQApi.describe_instances_with_http_infoY  s    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% **''KV#!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  describe_pl_whitelist  # 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_pl_whitelist(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribePLWhitelistRequest body: (required)
        :return: DescribePLWhitelistResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $describe_pl_whitelist_with_http_infor   s       r   describe_pl_whitelistz!ROCKETMQApi.describe_pl_whitelist  rq   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  describe_pl_whitelist  # 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_pl_whitelist_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribePLWhitelistRequest body: (required)
        :return: DescribePLWhitelistResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method describe_pl_whitelistNzJMissing the required parameter `body` when calling `describe_pl_whitelist`r   r   r   r    z?/DescribePLWhitelist/2023-01-01/rocketmq/post/application_json/r!   DescribePLWhitelistResponseTr#   r)   r4   s                  r   r   z0ROCKETMQApi.describe_pl_whitelist_with_http_info  rt   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_regions  # 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_regions(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeRegionsRequest body: (required)
        :return: DescribeRegionsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   describe_regions_with_http_infor   s       r   describe_regionszROCKETMQApi.describe_regions  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  describe_regions  # 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_regions_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeRegionsRequest body: (required)
        :return: DescribeRegionsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zBGot an unexpected keyword argument '%s' to method describe_regionsNzEMissing the required parameter `body` when calling `describe_regions`r   r   r   r    z;/DescribeRegions/2023-01-01/rocketmq/post/application_json/r!   DescribeRegionsResponseTr#   r)   r4   s                  r   r   z+ROCKETMQApi.describe_regions_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% **''I6#!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  describe_secret_key  # noqa: E501

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

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

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

        :param async_req bool
        :param DescribeSecretKeyRequest body: (required)
        :return: DescribeSecretKeyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zEGot an unexpected keyword argument '%s' to method describe_secret_keyNzHMissing the required parameter `body` when calling `describe_secret_key`r   r   r   r    z=/DescribeSecretKey/2023-01-01/rocketmq/post/application_json/r!   DescribeSecretKeyResponseTr#   r)   r4   s                  r   r  z.ROCKETMQApi.describe_secret_key_with_http_info|  rm   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_tags_by_resource  # noqa: E501

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

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

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

        :param async_req bool
        :param DescribeTagsByResourceRequest body: (required)
        :return: DescribeTagsByResourceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zKGot an unexpected keyword argument '%s' to method describe_tags_by_resourceNzNMissing the required parameter `body` when calling `describe_tags_by_resource`r   r   r   r    zB/DescribeTagsByResource/2023-01-01/rocketmq/post/application_json/r!   DescribeTagsByResourceResponseTr#   r)   r4   s                  r   r  z4ROCKETMQApi.describe_tags_by_resource_with_http_info      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% **''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_topic_access_policies  # noqa: E501

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

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

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

        :param async_req bool
        :param DescribeTopicAccessPoliciesRequest body: (required)
        :return: DescribeTopicAccessPoliciesResponse
                 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_topic_access_policiesNzSMissing the required parameter `body` when calling `describe_topic_access_policies`r   r   r   r    zG/DescribeTopicAccessPolicies/2023-01-01/rocketmq/post/application_json/r!   #DescribeTopicAccessPoliciesResponseTr#   r)   r4   s                  r   r  z9ROCKETMQApi.describe_topic_access_policies_with_http_info>  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_topic_detail  # 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_topic_detail(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeTopicDetailRequest body: (required)
        :return: DescribeTopicDetailResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $describe_topic_detail_with_http_infor   s       r   describe_topic_detailz!ROCKETMQApi.describe_topic_detail  rq   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  describe_topic_detail  # 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_topic_detail_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeTopicDetailRequest body: (required)
        :return: DescribeTopicDetailResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method describe_topic_detailNzJMissing the required parameter `body` when calling `describe_topic_detail`r   r   r   r    z?/DescribeTopicDetail/2023-01-01/rocketmq/post/application_json/r!   DescribeTopicDetailResponseTr#   r)   r4   s                  r   r  z0ROCKETMQApi.describe_topic_detail_with_http_info  rt   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_topic_groups  # noqa: E501

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

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

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

        :param async_req bool
        :param DescribeTopicGroupsRequest body: (required)
        :return: DescribeTopicGroupsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method describe_topic_groupsNzJMissing the required parameter `body` when calling `describe_topic_groups`r   r   r   r    z?/DescribeTopicGroups/2023-01-01/rocketmq/post/application_json/r!   DescribeTopicGroupsResponseTr#   r)   r4   s                  r   r  z0ROCKETMQApi.describe_topic_groups_with_http_info   rt   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_topic_queue  # 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_topic_queue(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeTopicQueueRequest body: (required)
        :return: DescribeTopicQueueResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #describe_topic_queue_with_http_infor   s       r   describe_topic_queuez ROCKETMQApi.describe_topic_queueL  rB   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  describe_topic_queue  # 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_topic_queue_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeTopicQueueRequest body: (required)
        :return: DescribeTopicQueueResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method describe_topic_queueNzIMissing the required parameter `body` when calling `describe_topic_queue`r   r   r   r    z>/DescribeTopicQueue/2023-01-01/rocketmq/post/application_json/r!   DescribeTopicQueueResponseTr#   r)   r4   s                  r   r  z/ROCKETMQApi.describe_topic_queue_with_http_infoa  rJ   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  describe_topics  # 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_topics(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeTopicsRequest body: (required)
        :return: DescribeTopicsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   describe_topics_with_http_infor   s       r   describe_topicszROCKETMQApi.describe_topics  rc   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  describe_topics  # 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_topics_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DescribeTopicsRequest body: (required)
        :return: DescribeTopicsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zAGot an unexpected keyword argument '%s' to method describe_topicsNzDMissing the required parameter `body` when calling `describe_topics`r   r   r   r    z:/DescribeTopics/2023-01-01/rocketmq/post/application_json/r!   DescribeTopicsResponseTr#   r)   r4   s                  r   r!  z*ROCKETMQApi.describe_topics_with_http_info  rf   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  disassociate_allow_list  # noqa: E501

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

        :param async_req bool
        :param DisassociateAllowListRequest body: (required)
        :return: DisassociateAllowListResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &disassociate_allow_list_with_http_infor   s       r   disassociate_allow_listz#ROCKETMQApi.disassociate_allow_list  ]     ,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"  disassociate_allow_list  # noqa: E501

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

        :param async_req bool
        :param DisassociateAllowListRequest body: (required)
        :return: DisassociateAllowListResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method disassociate_allow_listNzLMissing the required parameter `body` when calling `disassociate_allow_list`r   r   r   r    zA/DisassociateAllowList/2023-01-01/rocketmq/post/application_json/r!   DisassociateAllowListResponseTr#   r)   r4   s                  r   r&  z2ROCKETMQApi.disassociate_allow_list_with_http_info#      X
+&&&2333,---,---fX&677 	 	HC*$$9;>?   F3KK8?1 	mvV7K7K7=f~7MklllV .K"&/"F"F #" #"h )-(R(R )" )"n% **''OQW#!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  enable_auto_create_group  # noqa: E501

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

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

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

        :param async_req bool
        :param EnableAutoCreateGroupRequest body: (required)
        :return: EnableAutoCreateGroupResponse
                 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_auto_create_groupNzMMissing the required parameter `body` when calling `enable_auto_create_group`r   r   r   r    zA/EnableAutoCreateGroup/2023-01-01/rocketmq/post/application_json/r!   EnableAutoCreateGroupResponseTr#   r)   r4   s                  r   r-  z3ROCKETMQApi.enable_auto_create_group_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$:<?@   F3KK8?1 	nvV7K7K7=f~7MlmmmV .K"&/"F"F #" #"h )-(R(R )" )"n% **''OQW#!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  enable_instance_burst_tps  # 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_instance_burst_tps(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableInstanceBurstTpsRequest body: (required)
        :return: EnableInstanceBurstTpsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   (enable_instance_burst_tps_with_http_infor   s       r   enable_instance_burst_tpsz%ROCKETMQApi.enable_instance_burst_tps  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a(  enable_instance_burst_tps  # 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_instance_burst_tps_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableInstanceBurstTpsRequest body: (required)
        :return: EnableInstanceBurstTpsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zKGot an unexpected keyword argument '%s' to method enable_instance_burst_tpsNzNMissing the required parameter `body` when calling `enable_instance_burst_tps`r   r   r   r    zB/EnableInstanceBurstTps/2023-01-01/rocketmq/post/application_json/r!   EnableInstanceBurstTpsResponseTr#   r)   r4   s                  r   r2  z4ROCKETMQApi.enable_instance_burst_tps_with_http_info  r  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  enable_instance_inspect  # 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_instance_inspect(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableInstanceInspectRequest body: (required)
        :return: EnableInstanceInspectResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &enable_instance_inspect_with_http_infor   s       r   enable_instance_inspectz#ROCKETMQApi.enable_instance_inspect1  r(  r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a"  enable_instance_inspect  # 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_instance_inspect_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableInstanceInspectRequest body: (required)
        :return: EnableInstanceInspectResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method enable_instance_inspectNzLMissing the required parameter `body` when calling `enable_instance_inspect`r   r   r   r    zA/EnableInstanceInspect/2023-01-01/rocketmq/post/application_json/r!   EnableInstanceInspectResponseTr#   r)   r4   s                  r   r7  z2ROCKETMQApi.enable_instance_inspect_with_http_infoF  r+  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_inspect_config  # noqa: E501

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

        :param async_req bool
        :param GetInspectConfigRequest body: (required)
        :return: GetInspectConfigResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !get_inspect_config_with_http_infor   s       r   get_inspect_configzROCKETMQApi.get_inspect_config  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_inspect_config  # noqa: E501

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

        :param async_req bool
        :param GetInspectConfigRequest body: (required)
        :return: GetInspectConfigResponse
                 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_inspect_configNzGMissing the required parameter `body` when calling `get_inspect_config`r   r   r   r    z</GetInspectConfig/2023-01-01/rocketmq/post/application_json/r!   GetInspectConfigResponseTr#   r)   r4   s                  r   r<  z-ROCKETMQApi.get_inspect_config_with_http_info  r_   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a!  get_instance_inspect_result  # 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_instance_inspect_result(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetInstanceInspectResultRequest body: (required)
        :return: GetInstanceInspectResultResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   *get_instance_inspect_result_with_http_infor   s       r   get_instance_inspect_resultz'ROCKETMQApi.get_instance_inspect_result  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 )a0  get_instance_inspect_result  # 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_instance_inspect_result_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetInstanceInspectResultRequest body: (required)
        :return: GetInstanceInspectResultResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zMGot an unexpected keyword argument '%s' to method get_instance_inspect_resultNzPMissing the required parameter `body` when calling `get_instance_inspect_result`r   r   r   r    zD/GetInstanceInspectResult/2023-01-01/rocketmq/post/application_json/r!    GetInstanceInspectResultResponseTr#   r)   r4   s                  r   rA  z6ROCKETMQApi.get_instance_inspect_result_with_http_info      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% **''RTZ#!<'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  manual_process_result  # noqa: E501

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

        :param async_req bool
        :param ManualProcessResultRequest body: (required)
        :return: ManualProcessResultResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $manual_process_result_with_http_infor   s       r   manual_process_resultz!ROCKETMQApi.manual_process_resultT  rq   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  manual_process_result  # noqa: E501

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

        :param async_req bool
        :param ManualProcessResultRequest body: (required)
        :return: ManualProcessResultResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method manual_process_resultNzJMissing the required parameter `body` when calling `manual_process_result`r   r   r   r    z?/ManualProcessResult/2023-01-01/rocketmq/post/application_json/r!   ManualProcessResultResponseTr#   r)   r4   s                  r   rG  z0ROCKETMQApi.manual_process_result_with_http_infoi  rt   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  manual_trigger_inspect  # noqa: E501

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

        :param async_req bool
        :param ManualTriggerInspectRequest body: (required)
        :return: ManualTriggerInspectResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   %manual_trigger_inspect_with_http_infor   s       r   manual_trigger_inspectz"ROCKETMQApi.manual_trigger_inspect  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  manual_trigger_inspect  # noqa: E501

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

        :param async_req bool
        :param ManualTriggerInspectRequest body: (required)
        :return: ManualTriggerInspectResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method manual_trigger_inspectNzKMissing the required parameter `body` when calling `manual_trigger_inspect`r   r   r   r    z@/ManualTriggerInspect/2023-01-01/rocketmq/post/application_json/r!   ManualTriggerInspectResponseTr#   r)   r4   s                  r   rL  z1ROCKETMQApi.manual_trigger_inspect_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  message_send  # noqa: E501

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

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

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

        :param async_req bool
        :param MessageSendRequest body: (required)
        :return: MessageSendResponse
                 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 message_sendNzAMissing the required parameter `body` when calling `message_send`r   r   r   r    z7/MessageSend/2023-01-01/rocketmq/post/application_json/r!   MessageSendResponseTr#   r)   r4   s                  r   rQ  z'ROCKETMQApi.message_send_with_http_info+  rX   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a/  modify_access_key_all_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.modify_access_key_all_authority(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyAccessKeyAllAuthorityRequest body: (required)
        :return: ModifyAccessKeyAllAuthorityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   .modify_access_key_all_authority_with_http_infor   s       r   modify_access_key_all_authorityz+ROCKETMQApi.modify_access_key_all_authorityw  s^     ,0'(::k"" 	F4FtVVvVVVHTHXXQWXXTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a>  modify_access_key_all_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.modify_access_key_all_authority_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyAccessKeyAllAuthorityRequest body: (required)
        :return: ModifyAccessKeyAllAuthorityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zQGot an unexpected keyword argument '%s' to method modify_access_key_all_authorityNzTMissing the required parameter `body` when calling `modify_access_key_all_authority`r   r   r   r    zG/ModifyAccessKeyAllAuthority/2023-01-01/rocketmq/post/application_json/r!   #ModifyAccessKeyAllAuthorityResponseTr#   r)   r4   s                  r   rV  z:ROCKETMQApi.modify_access_key_all_authority_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$ACFG   F3KK8?1 	uvV7K7K7=f~7MstttV .K"&/"F"F #" #"h )-(R(R )" )"n% **''UW]#!?'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_access_key_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.modify_access_key_authority(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyAccessKeyAuthorityRequest body: (required)
        :return: ModifyAccessKeyAuthorityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   *modify_access_key_authority_with_http_infor   s       r   modify_access_key_authorityz'ROCKETMQApi.modify_access_key_authority  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 )a0  modify_access_key_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.modify_access_key_authority_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyAccessKeyAuthorityRequest body: (required)
        :return: ModifyAccessKeyAuthorityResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zMGot an unexpected keyword argument '%s' to method modify_access_key_authorityNzPMissing the required parameter `body` when calling `modify_access_key_authority`r   r   r   r    zD/ModifyAccessKeyAuthority/2023-01-01/rocketmq/post/application_json/r!    ModifyAccessKeyAuthorityResponseTr#   r)   r4   s                  r   r[  z6ROCKETMQApi.modify_access_key_authority_with_http_info  rE  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  modify_allow_list  # 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_allow_list(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyAllowListRequest body: (required)
        :return: ModifyAllowListResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r    modify_allow_list_with_http_infor   s       r   modify_allow_listzROCKETMQApi.modify_allow_list9  rN   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_allow_list  # 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_allow_list_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyAllowListRequest body: (required)
        :return: ModifyAllowListResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zCGot an unexpected keyword argument '%s' to method modify_allow_listNzFMissing the required parameter `body` when calling `modify_allow_list`r   r   r   r    z;/ModifyAllowList/2023-01-01/rocketmq/post/application_json/r!   ModifyAllowListResponseTr#   r)   r4   s                  r   r`  z,ROCKETMQApi.modify_allow_list_with_http_infoN  rQ   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  modify_group_description  # noqa: E501

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

        :param async_req bool
        :param ModifyGroupDescriptionRequest body: (required)
        :return: ModifyGroupDescriptionResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'modify_group_description_with_http_infor   s       r   modify_group_descriptionz$ROCKETMQApi.modify_group_description  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_group_description  # noqa: E501

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

        :param async_req bool
        :param ModifyGroupDescriptionRequest body: (required)
        :return: ModifyGroupDescriptionResponse
                 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_group_descriptionNzMMissing the required parameter `body` when calling `modify_group_description`r   r   r   r    zB/ModifyGroupDescription/2023-01-01/rocketmq/post/application_json/r!   ModifyGroupDescriptionResponseTr#   r)   r4   s                  r   re  z3ROCKETMQApi.modify_group_description_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  modify_instance_attributes  # noqa: E501

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

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

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

        :param async_req bool
        :param ModifyInstanceAttributesRequest body: (required)
        :return: ModifyInstanceAttributesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method modify_instance_attributesNzOMissing the required parameter `body` when calling `modify_instance_attributes`r   r   r   r    zD/ModifyInstanceAttributes/2023-01-01/rocketmq/post/application_json/r!    ModifyInstanceAttributesResponseTr#   r)   r4   s                  r   rj  z5ROCKETMQApi.modify_instance_attributes_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$<>AB   F3KK8?1 	pvV7K7K7=f~7MnoooV .K"&/"F"F #" #"h )-(R(R )" )"n% **''RTZ#!<'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_instance_charge_type  # noqa: E501

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

        :param async_req bool
        :param ModifyInstanceChargeTypeRequest body: (required)
        :return: ModifyInstanceChargeTypeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   *modify_instance_charge_type_with_http_infor   s       r   modify_instance_charge_typez'ROCKETMQApi.modify_instance_charge_type\  r   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a0  modify_instance_charge_type  # noqa: E501

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

        :param async_req bool
        :param ModifyInstanceChargeTypeRequest body: (required)
        :return: ModifyInstanceChargeTypeResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zMGot an unexpected keyword argument '%s' to method modify_instance_charge_typeNzPMissing the required parameter `body` when calling `modify_instance_charge_type`r   r   r   r    zD/ModifyInstanceChargeType/2023-01-01/rocketmq/post/application_json/r!    ModifyInstanceChargeTypeResponseTr#   r)   r4   s                  r   ro  z6ROCKETMQApi.modify_instance_charge_type_with_http_infoq  rE  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  modify_instance_spec  # 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_instance_spec(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyInstanceSpecRequest body: (required)
        :return: ModifyInstanceSpecResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #modify_instance_spec_with_http_infor   s       r   modify_instance_specz ROCKETMQApi.modify_instance_spec  rB   r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  modify_instance_spec  # 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_instance_spec_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ModifyInstanceSpecRequest body: (required)
        :return: ModifyInstanceSpecResponse
                 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_instance_specNzIMissing the required parameter `body` when calling `modify_instance_spec`r   r   r   r    z>/ModifyInstanceSpec/2023-01-01/rocketmq/post/application_json/r!   ModifyInstanceSpecResponseTr#   r)   r4   s                  r   rt  z/ROCKETMQApi.modify_instance_spec_with_http_info  rJ   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a%  modify_topic_access_policies  # noqa: E501

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

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

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

        :param async_req bool
        :param ModifyTopicAccessPoliciesRequest body: (required)
        :return: ModifyTopicAccessPoliciesResponse
                 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_topic_access_policiesNzQMissing the required parameter `body` when calling `modify_topic_access_policies`r   r   r   r    zE/ModifyTopicAccessPolicies/2023-01-01/rocketmq/post/application_json/r!   !ModifyTopicAccessPoliciesResponseTr#   r)   r4   s                  r   ry  z7ROCKETMQApi.modify_topic_access_policies_with_http_info3  s    X
+&&&2333,---,---fX&677 	 	HC*$$>@CD   F3KK8?1 	rvV7K7K7=f~7MpqqqV .K"&/"F"F #" #"h )-(R(R )" )"n% **''SU[#!='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_topic_description  # noqa: E501

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

        :param async_req bool
        :param ModifyTopicDescriptionRequest body: (required)
        :return: ModifyTopicDescriptionResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'modify_topic_description_with_http_infor   s       r   modify_topic_descriptionz$ROCKETMQApi.modify_topic_description  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_topic_description  # noqa: E501

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

        :param async_req bool
        :param ModifyTopicDescriptionRequest body: (required)
        :return: ModifyTopicDescriptionResponse
                 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_topic_descriptionNzMMissing the required parameter `body` when calling `modify_topic_description`r   r   r   r    zB/ModifyTopicDescription/2023-01-01/rocketmq/post/application_json/r!   ModifyTopicDescriptionResponseTr#   r)   r4   s                  r   r~  z3ROCKETMQApi.modify_topic_description_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a%  query_dlq_message_by_group_id  # noqa: E501

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

        :param async_req bool
        :param QueryDLQMessageByGroupIdRequest body: (required)
        :return: QueryDLQMessageByGroupIdResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   ,query_dlq_message_by_group_id_with_http_infor   s       r   query_dlq_message_by_group_idz)ROCKETMQApi.query_dlq_message_by_group_id  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 )a4  query_dlq_message_by_group_id  # noqa: E501

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

        :param async_req bool
        :param QueryDLQMessageByGroupIdRequest body: (required)
        :return: QueryDLQMessageByGroupIdResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zOGot an unexpected keyword argument '%s' to method query_dlq_message_by_group_idNzRMissing the required parameter `body` when calling `query_dlq_message_by_group_id`r   r   r   r    zD/QueryDLQMessageByGroupId/2023-01-01/rocketmq/post/application_json/r!    QueryDLQMessageByGroupIdResponseTr#   r)   r4   s                  r   r  z8ROCKETMQApi.query_dlq_message_by_group_id_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% **''RTZ#!<'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  query_dlq_message_by_id  # noqa: E501

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

        :param async_req bool
        :param QueryDLQMessageByIdRequest body: (required)
        :return: QueryDLQMessageByIdResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &query_dlq_message_by_id_with_http_infor   s       r   query_dlq_message_by_idz#ROCKETMQApi.query_dlq_message_by_idA  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  query_dlq_message_by_id  # noqa: E501

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

        :param async_req bool
        :param QueryDLQMessageByIdRequest body: (required)
        :return: QueryDLQMessageByIdResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method query_dlq_message_by_idNzLMissing the required parameter `body` when calling `query_dlq_message_by_id`r   r   r   r    z?/QueryDLQMessageById/2023-01-01/rocketmq/post/application_json/r!   QueryDLQMessageByIdResponseTr#   r)   r4   s                  r   r  z2ROCKETMQApi.query_dlq_message_by_id_with_http_infoV      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% **''Mv#!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  query_message_by_msg_id  # noqa: E501

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

        :param async_req bool
        :param QueryMessageByMsgIdRequest body: (required)
        :return: QueryMessageByMsgIdResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &query_message_by_msg_id_with_http_infor   s       r   query_message_by_msg_idz#ROCKETMQApi.query_message_by_msg_id  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  query_message_by_msg_id  # noqa: E501

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

        :param async_req bool
        :param QueryMessageByMsgIdRequest body: (required)
        :return: QueryMessageByMsgIdResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method query_message_by_msg_idNzLMissing the required parameter `body` when calling `query_message_by_msg_id`r   r   r   r    z?/QueryMessageByMsgId/2023-01-01/rocketmq/post/application_json/r!   QueryMessageByMsgIdResponseTr#   r)   r4   s                  r   r  z2ROCKETMQApi.query_message_by_msg_id_with_http_info  r  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  query_message_by_msg_key  # noqa: E501

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

        :param async_req bool
        :param QueryMessageByMsgKeyRequest body: (required)
        :return: QueryMessageByMsgKeyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'query_message_by_msg_key_with_http_infor   s       r   query_message_by_msg_keyz$ROCKETMQApi.query_message_by_msg_key  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"  query_message_by_msg_key  # noqa: E501

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

        :param async_req bool
        :param QueryMessageByMsgKeyRequest body: (required)
        :return: QueryMessageByMsgKeyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zJGot an unexpected keyword argument '%s' to method query_message_by_msg_keyNzMMissing the required parameter `body` when calling `query_message_by_msg_key`r   r   r   r    z@/QueryMessageByMsgKey/2023-01-01/rocketmq/post/application_json/r!   QueryMessageByMsgKeyResponseTr#   r)   r4   s                  r   r  z3ROCKETMQApi.query_message_by_msg_key_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% **''NPV#!8'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  query_message_by_offset  # noqa: E501

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

        :param async_req bool
        :param QueryMessageByOffsetRequest body: (required)
        :return: QueryMessageByOffsetResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &query_message_by_offset_with_http_infor   s       r   query_message_by_offsetz#ROCKETMQApi.query_message_by_offsetd  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   query_message_by_offset  # noqa: E501

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

        :param async_req bool
        :param QueryMessageByOffsetRequest body: (required)
        :return: QueryMessageByOffsetResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method query_message_by_offsetNzLMissing the required parameter `body` when calling `query_message_by_offset`r   r   r   r    z@/QueryMessageByOffset/2023-01-01/rocketmq/post/application_json/r!   QueryMessageByOffsetResponseTr#   r)   r4   s                  r   r  z2ROCKETMQApi.query_message_by_offset_with_http_infoy  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% **''NPV#!8'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  query_message_by_timestamp  # noqa: E501

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

        :param async_req bool
        :param QueryMessageByTimestampRequest body: (required)
        :return: QueryMessageByTimestampResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )query_message_by_timestamp_with_http_infor   s       r   query_message_by_timestampz&ROCKETMQApi.query_message_by_timestamp  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,  query_message_by_timestamp  # noqa: E501

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

        :param async_req bool
        :param QueryMessageByTimestampRequest body: (required)
        :return: QueryMessageByTimestampResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method query_message_by_timestampNzOMissing the required parameter `body` when calling `query_message_by_timestamp`r   r   r   r    zC/QueryMessageByTimestamp/2023-01-01/rocketmq/post/application_json/r!   QueryMessageByTimestampResponseTr#   r)   r4   s                  r   r  z5ROCKETMQApi.query_message_by_timestamp_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a5  query_message_trace_by_message_id  # noqa: E501

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

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

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

        :param async_req bool
        :param QueryMessageTraceByMessageIdRequest body: (required)
        :return: QueryMessageTraceByMessageIdResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zSGot an unexpected keyword argument '%s' to method query_message_trace_by_message_idNzVMissing the required parameter `body` when calling `query_message_trace_by_message_id`r   r   r   r    zH/QueryMessageTraceByMessageId/2023-01-01/rocketmq/post/application_json/r!   $QueryMessageTraceByMessageIdResponseTr#   r)   r4   s                  r   r  z<ROCKETMQApi.query_message_trace_by_message_id_with_http_info;  s    X
+&&&2333,---,---fX&677 	 	HC*$$CEHI   F3KK8?1 	wvV7K7K7=f~7MuvvvV .K"&/"F"F #" #"h )-(R(R )" )"n% **''VX^#!@'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  remove_pl_whitelist  # noqa: E501

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

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

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

        :param async_req bool
        :param RemovePLWhitelistRequest body: (required)
        :return: RemovePLWhitelistResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zEGot an unexpected keyword argument '%s' to method remove_pl_whitelistNzHMissing the required parameter `body` when calling `remove_pl_whitelist`r   r   r   r    z=/RemovePLWhitelist/2023-01-01/rocketmq/post/application_json/r!   RemovePLWhitelistResponseTr#   r)   r4   s                  r   r  z.ROCKETMQApi.remove_pl_whitelist_with_http_info  rm   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  remove_tags_from_resource  # noqa: E501

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

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

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

        :param async_req bool
        :param RemoveTagsFromResourceRequest body: (required)
        :return: RemoveTagsFromResourceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zKGot an unexpected keyword argument '%s' to method remove_tags_from_resourceNzNMissing the required parameter `body` when calling `remove_tags_from_resource`r   r   r   r    zB/RemoveTagsFromResource/2023-01-01/rocketmq/post/application_json/r!   RemoveTagsFromResourceResponseTr#   r)   r4   s                  r   r  z4ROCKETMQApi.remove_tags_from_resource_with_http_info  r  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  resend_dlq_message_by_id  # noqa: E501

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

        :param async_req bool
        :param ResendDLQMessageByIdRequest body: (required)
        :return: ResendDLQMessageByIdResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'resend_dlq_message_by_id_with_http_infor   s       r   resend_dlq_message_by_idz$ROCKETMQApi.resend_dlq_message_by_idI  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"  resend_dlq_message_by_id  # noqa: E501

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

        :param async_req bool
        :param ResendDLQMessageByIdRequest body: (required)
        :return: ResendDLQMessageByIdResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zJGot an unexpected keyword argument '%s' to method resend_dlq_message_by_idNzMMissing the required parameter `body` when calling `resend_dlq_message_by_id`r   r   r   r    z@/ResendDLQMessageById/2023-01-01/rocketmq/post/application_json/r!   ResendDLQMessageByIdResponseTr#   r)   r4   s                  r   r  z3ROCKETMQApi.resend_dlq_message_by_id_with_http_info^  r  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  reset_consumed_offsets  # noqa: E501

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

        :param async_req bool
        :param ResetConsumedOffsetsRequest body: (required)
        :return: ResetConsumedOffsetsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   %reset_consumed_offsets_with_http_infor   s       r   reset_consumed_offsetsz"ROCKETMQApi.reset_consumed_offsets  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  reset_consumed_offsets  # noqa: E501

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

        :param async_req bool
        :param ResetConsumedOffsetsRequest body: (required)
        :return: ResetConsumedOffsetsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method reset_consumed_offsetsNzKMissing the required parameter `body` when calling `reset_consumed_offsets`r   r   r   r    z@/ResetConsumedOffsets/2023-01-01/rocketmq/post/application_json/r!   ResetConsumedOffsetsResponseTr#   r)   r4   s                  r   r  z1ROCKETMQApi.reset_consumed_offsets_with_http_info  r   r   r   )__name__
__module____qualname____doc__r   r   r   rA   r@   rG   rF   rM   rL   rT   rS   r[   rZ   rb   ra   ri   rh   rp   ro   rw   rv   r|   r{   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r  r  r  r  r  r  r  r  r"  r!  r'  r&  r.  r-  r3  r2  r8  r7  r=  r<  rB  rA  rH  rG  rM  rL  rR  rQ  rW  rV  r\  r[  ra  r`  rf  re  rk  rj  rp  ro  ru  rt  rz  ry  r  r~  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r   r   r   r      s	        % % % %
  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3 J3 J3r   r   )r  
__future__r   rer,   r   objectr   r  r   r   <module>r     s     ' & & & & & 				 


    qk3 qk3 qk3 qk3 qk3& qk3 qk3 qk3 qk3 qk3r   