
    ~il                    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
    vmp

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

    OpenAPI spec version: common-version
    
    Generated by: https://github.com/swagger-api/swagger-codegen.git
    )absolute_importNc                      e Zd ZdZddZd Zd Zd Zd Zd Z	d	 Z
d
 Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Z d  Z!d! Z"d" Z#d# Z$d$ Z%d% Z&d& Z'd' Z(d( Z)d) Z*d* Z+d+ Z,d, Z-d- Z.d. Z/d/ Z0d0 Z1d1 Z2d2 Z3d3 Z4d4 Z5d5 Z6d6 Z7d7 Z8d8 Z9d9 Z:d: Z;d; Z<d< Z=d= Z>d> Z?d? Z@d@ ZAdA ZBdB ZCdC ZDdD ZEdE ZFdF ZGdG ZHdH ZIdI ZJdJ ZKdK ZLdL ZMdM ZNdN ZOdO ZPdP ZQdQ ZRdR ZSdS ZTdT ZUdU ZVdV ZWdW ZXdX ZYdY ZZdZ Z[d[ Z\d\ Z]d] Z^d^ Z_d_ Z`d` Zada Zbdb Zcdc Zddd Zede Zfdf Zgdg Zhdh Zidi Zjdj Zkdk Zldl Zmdm Zndn Zodo Zpdp Zqdq Zrdr Zsds Ztdt Zudu Zvdv Zwdw Zxdx Zydy Zzdz Z{d{ Z|d| Z}d} Z~d~ Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd ZdS )VMPApizNOTE: This class is auto generated by the swagger code generator program.

    Do not edit the class manually.
    Ref: https://github.com/swagger-api/swagger-codegen
    Nc                 >    |t          j                    }|| _        d S N)volcenginesdkcore	ApiClient
api_client)selfr
   s     e/root/.openclaw/workspace/.venvs/ark-sdk/lib/python3.11/site-packages/volcenginesdkvmp/api/vmp_api.py__init__zVMPApi.__init__   s!    *466J$    c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_aggregate_workspace  # 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_aggregate_workspace(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateAggregateWorkspaceRequest body: (required)
        :return: CreateAggregateWorkspaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        T_return_http_data_only	async_req)get)create_aggregate_workspace_with_http_infor   bodykwargsdatas       r   create_aggregate_workspacez!VMPApi.create_aggregate_workspace$   ]     ,0'(::k"" 	A4A$QQ&QQQCTCDSSFSSTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a.  create_aggregate_workspace  # 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_aggregate_workspace_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateAggregateWorkspaceRequest body: (required)
        :return: CreateAggregateWorkspaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   _preload_content_request_timeoutr   zLGot an unexpected keyword argument '%s' to method create_aggregate_workspaceNzOMissing the required parameter `body` when calling `create_aggregate_workspace`application/jsonAcceptContent-TypevolcengineSignz?/CreateAggregateWorkspace/2021-03-03/vmp/post/application_json/POST CreateAggregateWorkspaceResponseT
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   z0VMPApi.create_aggregate_workspace_with_http_info9       X
+&&&2333,---,---fX&677 	 	HC*$$<>AB   F3KK8?1 	pvV7K7K7=f~7MnoooV .K"&/"F"F #" #"h )-(R(R )" )"n% **''Mv#!<'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_alerting_rule  # 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_alerting_rule(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateAlertingRuleRequest body: (required)
        :return: CreateAlertingRuleResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #create_alerting_rule_with_http_infor   s       r   create_alerting_rulezVMPApi.create_alerting_rule   ]     ,0'(::k"" 	;4;DKKFKKK=T=dMMfMMTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  create_alerting_rule  # 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_alerting_rule_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateAlertingRuleRequest body: (required)
        :return: CreateAlertingRuleResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method create_alerting_ruleNzIMissing the required parameter `body` when calling `create_alerting_rule`r   r   r   r    z9/CreateAlertingRule/2021-03-03/vmp/post/application_json/r!   CreateAlertingRuleResponseTr#   r)   r4   s                  r   rA   z*VMPApi.create_alerting_rule_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% **''G#!6'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_contact  # 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_contact(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateContactRequest body: (required)
        :return: CreateContactResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   create_contact_with_http_infor   s       r   create_contactzVMPApi.create_contact   ]     ,0'(::k"" 	545dEEfEEE7T7GGGGTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a   create_contact  # 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_contact_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateContactRequest body: (required)
        :return: CreateContactResponse
                 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_contactNzCMissing the required parameter `body` when calling `create_contact`r   r   r   r    z4/CreateContact/2021-03-03/vmp/post/application_json/r!   CreateContactResponseTr#   r)   r4   s                  r   rH   z$VMPApi.create_contact_with_http_info       X
+&&&2333,---,---fX&677 	 	HC*$$0256   F3KK8?1 	dvV7K7K7=f~7MbcccV .K"&/"F"F #" #"h )-(R(R )" )"n% **''BF#!1'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_contact_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_contact_group(body, async_req=True)
        >>> result = thread.get()

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

        :param async_req bool
        :param CreateContactGroupRequest body: (required)
        :return: CreateContactGroupResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method create_contact_groupNzIMissing the required parameter `body` when calling `create_contact_group`r   r   r   r    z9/CreateContactGroup/2021-03-03/vmp/post/application_json/r!   CreateContactGroupResponseTr#   r)   r4   s                  r   rO   z*VMPApi.create_contact_group_with_http_info\  rF   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_external_prometheus  # 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_external_prometheus(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateExternalPrometheusRequest body: (required)
        :return: CreateExternalPrometheusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )create_external_prometheus_with_http_infor   s       r   create_external_prometheusz!VMPApi.create_external_prometheus  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_external_prometheus  # 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_external_prometheus_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateExternalPrometheusRequest body: (required)
        :return: CreateExternalPrometheusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method create_external_prometheusNzOMissing the required parameter `body` when calling `create_external_prometheus`r   r   r   r    z?/CreateExternalPrometheus/2021-03-03/vmp/post/application_json/r!    CreateExternalPrometheusResponseTr#   r)   r4   s                  r   rT   z0VMPApi.create_external_prometheus_with_http_info  r?   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_integration_task  # 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_integration_task(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateIntegrationTaskRequest body: (required)
        :return: CreateIntegrationTaskResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &create_integration_task_with_http_infor   s       r   create_integration_taskzVMPApi.create_integration_task	  ]     ,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"  create_integration_task  # 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_integration_task_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateIntegrationTaskRequest body: (required)
        :return: CreateIntegrationTaskResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method create_integration_taskNzLMissing the required parameter `body` when calling `create_integration_task`r   r   r   r    z</CreateIntegrationTask/2021-03-03/vmp/post/application_json/r!   CreateIntegrationTaskResponseTr#   r)   r4   s                  r   rY   z-VMPApi.create_integration_task_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% **''JF#!9'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_notify_group_policy  # noqa: E501

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

        :param async_req bool
        :param CreateNotifyGroupPolicyRequest body: (required)
        :return: CreateNotifyGroupPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )create_notify_group_policy_with_http_infor   s       r   create_notify_group_policyz!VMPApi.create_notify_group_policyj  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_notify_group_policy  # noqa: E501

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

        :param async_req bool
        :param CreateNotifyGroupPolicyRequest body: (required)
        :return: CreateNotifyGroupPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method create_notify_group_policyNzOMissing the required parameter `body` when calling `create_notify_group_policy`r   r   r   r    z>/CreateNotifyGroupPolicy/2021-03-03/vmp/post/application_json/r!   CreateNotifyGroupPolicyResponseTr#   r)   r4   s                  r   r`   z0VMPApi.create_notify_group_policy_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% **''Lf#!;'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_notify_policy  # noqa: E501

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

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

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

        :param async_req bool
        :param CreateNotifyPolicyRequest body: (required)
        :return: CreateNotifyPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method create_notify_policyNzIMissing the required parameter `body` when calling `create_notify_policy`r   r   r   r    z9/CreateNotifyPolicy/2021-03-03/vmp/post/application_json/r!   CreateNotifyPolicyResponseTr#   r)   r4   s                  r   rf   z*VMPApi.create_notify_policy_with_http_info  rF   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_notify_template  # 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_notify_template(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateNotifyTemplateRequest body: (required)
        :return: CreateNotifyTemplateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   %create_notify_template_with_http_infor   s       r   create_notify_templatezVMPApi.create_notify_template,  ]     ,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  create_notify_template  # 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_notify_template_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateNotifyTemplateRequest body: (required)
        :return: CreateNotifyTemplateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method create_notify_templateNzKMissing the required parameter `body` when calling `create_notify_template`r   r   r   r    z;/CreateNotifyTemplate/2021-03-03/vmp/post/application_json/r!   CreateNotifyTemplateResponseTr#   r)   r4   s                  r   rk   z,VMPApi.create_notify_template_with_http_infoA      X
+&&&2333,---,---fX&677 	 	HC*$$8:=>   F3KK8?1 	lvV7K7K7=f~7MjkkkV .K"&/"F"F #" #"h )-(R(R )" )"n% **''I6#!8'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_rule_file  # 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_rule_file(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateRuleFileRequest body: (required)
        :return: CreateRuleFileResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   create_rule_file_with_http_infor   s       r   create_rule_filezVMPApi.create_rule_file  ]     ,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  create_rule_file  # 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_rule_file_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateRuleFileRequest body: (required)
        :return: CreateRuleFileResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zBGot an unexpected keyword argument '%s' to method create_rule_fileNzEMissing the required parameter `body` when calling `create_rule_file`r   r   r   r    z5/CreateRuleFile/2021-03-03/vmp/post/application_json/r!   CreateRuleFileResponseTr#   r)   r4   s                  r   rr   z&VMPApi.create_rule_file_with_http_info      X
+&&&2333,---,---fX&677 	 	HC*$$2478   F3KK8?1 	fvV7K7K7=f~7MdeeeV .K"&/"F"F #" #"h )-(R(R )" )"n% **''CV#!2'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_silence_policy  # noqa: E501

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

        :param async_req bool
        :param CreateSilencePolicyRequest body: (required)
        :return: CreateSilencePolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $create_silence_policy_with_http_infor   s       r   create_silence_policyzVMPApi.create_silence_policy  ]     ,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_silence_policy  # noqa: E501

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

        :param async_req bool
        :param CreateSilencePolicyRequest body: (required)
        :return: CreateSilencePolicyResponse
                 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_silence_policyNzJMissing the required parameter `body` when calling `create_silence_policy`r   r   r   r    z:/CreateSilencePolicy/2021-03-03/vmp/post/application_json/r!   CreateSilencePolicyResponseTr#   r)   r4   s                  r   ry   z+VMPApi.create_silence_policy_with_http_info      X
+&&&2333,---,---fX&677 	 	HC*$$79<=   F3KK8?1 	kvV7K7K7=f~7MijjjV .K"&/"F"F #" #"h )-(R(R )" )"n% **''H&#!7'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  create_workspace  # 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_workspace(body, async_req=True)
        >>> result = thread.get()

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

        :param async_req bool
        :param CreateWorkspaceRequest body: (required)
        :return: CreateWorkspaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zBGot an unexpected keyword argument '%s' to method create_workspaceNzEMissing the required parameter `body` when calling `create_workspace`r   r   r   r    z6/CreateWorkspace/2021-03-03/vmp/post/application_json/r!   CreateWorkspaceResponseTr#   r)   r4   s                  r   r   z&VMPApi.create_workspace_with_http_infod      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% **''Df#!3'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_aggregate_workspace  # 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_aggregate_workspace(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteAggregateWorkspaceRequest body: (required)
        :return: DeleteAggregateWorkspaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )delete_aggregate_workspace_with_http_infor   s       r   delete_aggregate_workspacez!VMPApi.delete_aggregate_workspace  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_aggregate_workspace  # 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_aggregate_workspace_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteAggregateWorkspaceRequest body: (required)
        :return: DeleteAggregateWorkspaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method delete_aggregate_workspaceNzOMissing the required parameter `body` when calling `delete_aggregate_workspace`r   r   r   r    z?/DeleteAggregateWorkspace/2021-03-03/vmp/post/application_json/r!    DeleteAggregateWorkspaceResponseTr#   r)   r4   s                  r   r   z0VMPApi.delete_aggregate_workspace_with_http_info  r?   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_alerting_rules  # noqa: E501

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

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

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

        :param async_req bool
        :param DeleteAlertingRulesRequest body: (required)
        :return: DeleteAlertingRulesResponse
                 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_alerting_rulesNzJMissing the required parameter `body` when calling `delete_alerting_rules`r   r   r   r    z:/DeleteAlertingRules/2021-03-03/vmp/post/application_json/r!   DeleteAlertingRulesResponseTr#   r)   r4   s                  r   r   z+VMPApi.delete_alerting_rules_with_http_info&  r~   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_contact_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_contact_groups(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteContactGroupsRequest body: (required)
        :return: DeleteContactGroupsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $delete_contact_groups_with_http_infor   s       r   delete_contact_groupszVMPApi.delete_contact_groupsr  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_contact_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_contact_groups_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteContactGroupsRequest body: (required)
        :return: DeleteContactGroupsResponse
                 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_contact_groupsNzJMissing the required parameter `body` when calling `delete_contact_groups`r   r   r   r    z:/DeleteContactGroups/2021-03-03/vmp/post/application_json/r!   DeleteContactGroupsResponseTr#   r)   r4   s                  r   r   z+VMPApi.delete_contact_groups_with_http_info  r~   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_contacts  # 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_contacts(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteContactsRequest body: (required)
        :return: DeleteContactsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   delete_contacts_with_http_infor   s       r   delete_contactszVMPApi.delete_contacts  ]     ,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  delete_contacts  # 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_contacts_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteContactsRequest body: (required)
        :return: DeleteContactsResponse
                 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_contactsNzDMissing the required parameter `body` when calling `delete_contacts`r   r   r   r    z5/DeleteContacts/2021-03-03/vmp/post/application_json/r!   DeleteContactsResponseTr#   r)   r4   s                  r   r   z%VMPApi.delete_contacts_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% **''CV#!2'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_external_prometheus  # 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_external_prometheus(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteExternalPrometheusRequest body: (required)
        :return: DeleteExternalPrometheusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )delete_external_prometheus_with_http_infor   s       r   delete_external_prometheusz!VMPApi.delete_external_prometheus4  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_external_prometheus  # 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_external_prometheus_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteExternalPrometheusRequest body: (required)
        :return: DeleteExternalPrometheusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method delete_external_prometheusNzOMissing the required parameter `body` when calling `delete_external_prometheus`r   r   r   r    z?/DeleteExternalPrometheus/2021-03-03/vmp/post/application_json/r!    DeleteExternalPrometheusResponseTr#   r)   r4   s                  r   r   z0VMPApi.delete_external_prometheus_with_http_infoI  r?   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_integration_task  # 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_integration_task(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteIntegrationTaskRequest body: (required)
        :return: DeleteIntegrationTaskResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &delete_integration_task_with_http_infor   s       r   delete_integration_taskzVMPApi.delete_integration_task  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_integration_task  # 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_integration_task_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteIntegrationTaskRequest body: (required)
        :return: DeleteIntegrationTaskResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method delete_integration_taskNzLMissing the required parameter `body` when calling `delete_integration_task`r   r   r   r    z</DeleteIntegrationTask/2021-03-03/vmp/post/application_json/r!   DeleteIntegrationTaskResponseTr#   r)   r4   s                  r   r   z-VMPApi.delete_integration_task_with_http_info  r^   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_notify_group_policy  # noqa: E501

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

        :param async_req bool
        :param DeleteNotifyGroupPolicyRequest body: (required)
        :return: DeleteNotifyGroupPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )delete_notify_group_policy_with_http_infor   s       r   delete_notify_group_policyz!VMPApi.delete_notify_group_policy  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_notify_group_policy  # noqa: E501

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

        :param async_req bool
        :param DeleteNotifyGroupPolicyRequest body: (required)
        :return: DeleteNotifyGroupPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method delete_notify_group_policyNzOMissing the required parameter `body` when calling `delete_notify_group_policy`r   r   r   r    z>/DeleteNotifyGroupPolicy/2021-03-03/vmp/post/application_json/r!   DeleteNotifyGroupPolicyResponseTr#   r)   r4   s                  r   r   z0VMPApi.delete_notify_group_policy_with_http_info  rd   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_notify_policy  # noqa: E501

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

        :param async_req bool
        :param DeleteNotifyPolicyRequest body: (required)
        :return: DeleteNotifyPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #delete_notify_policy_with_http_infor   s       r   delete_notify_policyzVMPApi.delete_notify_policyW  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_notify_policy  # noqa: E501

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

        :param async_req bool
        :param DeleteNotifyPolicyRequest body: (required)
        :return: DeleteNotifyPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method delete_notify_policyNzIMissing the required parameter `body` when calling `delete_notify_policy`r   r   r   r    z9/DeleteNotifyPolicy/2021-03-03/vmp/post/application_json/r!   DeleteNotifyPolicyResponseTr#   r)   r4   s                  r   r   z*VMPApi.delete_notify_policy_with_http_infol  rF   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_notify_template  # 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_notify_template(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteNotifyTemplateRequest body: (required)
        :return: DeleteNotifyTemplateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   %delete_notify_template_with_http_infor   s       r   delete_notify_templatezVMPApi.delete_notify_template  rm   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_notify_template  # 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_notify_template_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteNotifyTemplateRequest body: (required)
        :return: DeleteNotifyTemplateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method delete_notify_templateNzKMissing the required parameter `body` when calling `delete_notify_template`r   r   r   r    z;/DeleteNotifyTemplate/2021-03-03/vmp/post/application_json/r!   DeleteNotifyTemplateResponseTr#   r)   r4   s                  r   r   z,VMPApi.delete_notify_template_with_http_info  rp   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_rule_file  # 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_rule_file(body, async_req=True)
        >>> result = thread.get()

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

        :param async_req bool
        :param DeleteRuleFileRequest body: (required)
        :return: DeleteRuleFileResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zBGot an unexpected keyword argument '%s' to method delete_rule_fileNzEMissing the required parameter `body` when calling `delete_rule_file`r   r   r   r    z5/DeleteRuleFile/2021-03-03/vmp/post/application_json/r!   DeleteRuleFileResponseTr#   r)   r4   s                  r   r   z&VMPApi.delete_rule_file_with_http_info.  rw   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_silence_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.delete_silence_policies(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteSilencePoliciesRequest body: (required)
        :return: DeleteSilencePoliciesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &delete_silence_policies_with_http_infor   s       r   delete_silence_policieszVMPApi.delete_silence_policiesz  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_silence_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.delete_silence_policies_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DeleteSilencePoliciesRequest body: (required)
        :return: DeleteSilencePoliciesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method delete_silence_policiesNzLMissing the required parameter `body` when calling `delete_silence_policies`r   r   r   r    z</DeleteSilencePolicies/2021-03-03/vmp/post/application_json/r!   DeleteSilencePoliciesResponseTr#   r)   r4   s                  r   r   z-VMPApi.delete_silence_policies_with_http_info  r^   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  delete_workspace  # 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_workspace(body, async_req=True)
        >>> result = thread.get()

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

        :param async_req bool
        :param DeleteWorkspaceRequest body: (required)
        :return: DeleteWorkspaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zBGot an unexpected keyword argument '%s' to method delete_workspaceNzEMissing the required parameter `body` when calling `delete_workspace`r   r   r   r    z6/DeleteWorkspace/2021-03-03/vmp/post/application_json/r!   DeleteWorkspaceResponseTr#   r)   r4   s                  r   r   z&VMPApi.delete_workspace_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  disable_alerting_rules  # noqa: E501

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

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

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

        :param async_req bool
        :param DisableAlertingRulesRequest body: (required)
        :return: DisableAlertingRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method disable_alerting_rulesNzKMissing the required parameter `body` when calling `disable_alerting_rules`r   r   r   r    z;/DisableAlertingRules/2021-03-03/vmp/post/application_json/r!   DisableAlertingRulesResponseTr#   r)   r4   s                  r   r   z,VMPApi.disable_alerting_rules_with_http_infoQ	  rp   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  disable_integration_tasks  # noqa: E501

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

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

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

        :param async_req bool
        :param DisableIntegrationTasksRequest body: (required)
        :return: DisableIntegrationTasksResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zKGot an unexpected keyword argument '%s' to method disable_integration_tasksNzNMissing the required parameter `body` when calling `disable_integration_tasks`r   r   r   r    z>/DisableIntegrationTasks/2021-03-03/vmp/post/application_json/r!   DisableIntegrationTasksResponseTr#   r)   r4   s                  r   r   z/VMPApi.disable_integration_tasks_with_http_info	  s    X
+&&&2333,---,---fX&677 	 	HC*$$;=@A   F3KK8?1 	ovV7K7K7=f~7MmnnnV .K"&/"F"F #" #"h )-(R(R )" )"n% **''Lf#!;'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  disable_silence_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.disable_silence_policies(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DisableSilencePoliciesRequest body: (required)
        :return: DisableSilencePoliciesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'disable_silence_policies_with_http_infor   s       r   disable_silence_policieszVMPApi.disable_silence_policies	  ]     ,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&  disable_silence_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.disable_silence_policies_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DisableSilencePoliciesRequest body: (required)
        :return: DisableSilencePoliciesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zJGot an unexpected keyword argument '%s' to method disable_silence_policiesNzMMissing the required parameter `body` when calling `disable_silence_policies`r   r   r   r    z=/DisableSilencePolicies/2021-03-03/vmp/post/application_json/r!   DisableSilencePoliciesResponseTr#   r)   r4   s                  r   r   z.VMPApi.disable_silence_policies_with_http_info
      X
+&&&2333,---,---fX&677 	 	HC*$$:<?@   F3KK8?1 	nvV7K7K7=f~7MlmmmV .K"&/"F"F #" #"h )-(R(R )" )"n% **''KV#!:'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  enable_alerting_rules  # noqa: E501

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

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

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

        :param async_req bool
        :param EnableAlertingRulesRequest body: (required)
        :return: EnableAlertingRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method enable_alerting_rulesNzJMissing the required parameter `body` when calling `enable_alerting_rules`r   r   r   r    z:/EnableAlertingRules/2021-03-03/vmp/post/application_json/r!   EnableAlertingRulesResponseTr#   r)   r4   s                  r   r   z+VMPApi.enable_alerting_rules_with_http_infot
  r~   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  enable_integration_tasks  # 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_integration_tasks(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableIntegrationTasksRequest body: (required)
        :return: EnableIntegrationTasksResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   'enable_integration_tasks_with_http_infor   s       r   enable_integration_taskszVMPApi.enable_integration_tasks
  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_integration_tasks  # 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_integration_tasks_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableIntegrationTasksRequest body: (required)
        :return: EnableIntegrationTasksResponse
                 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_integration_tasksNzMMissing the required parameter `body` when calling `enable_integration_tasks`r   r   r   r    z=/EnableIntegrationTasks/2021-03-03/vmp/post/application_json/r!   EnableIntegrationTasksResponseTr#   r)   r4   s                  r   r   z.VMPApi.enable_integration_tasks_with_http_info
  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  enable_silence_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.enable_silence_policies(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableSilencePoliciesRequest body: (required)
        :return: EnableSilencePoliciesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &enable_silence_policies_with_http_infor   s       r   enable_silence_policieszVMPApi.enable_silence_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"  enable_silence_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.enable_silence_policies_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param EnableSilencePoliciesRequest body: (required)
        :return: EnableSilencePoliciesResponse
                 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_silence_policiesNzLMissing the required parameter `body` when calling `enable_silence_policies`r   r   r   r    z</EnableSilencePolicies/2021-03-03/vmp/post/application_json/r!   EnableSilencePoliciesResponseTr#   r)   r4   s                  r   r   z-VMPApi.enable_silence_policies_with_http_info6  r^   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_aggregate_workspace  # 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_aggregate_workspace(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetAggregateWorkspaceRequest body: (required)
        :return: GetAggregateWorkspaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &get_aggregate_workspace_with_http_infor   s       r   get_aggregate_workspacezVMPApi.get_aggregate_workspace  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_aggregate_workspace  # 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_aggregate_workspace_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetAggregateWorkspaceRequest body: (required)
        :return: GetAggregateWorkspaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method get_aggregate_workspaceNzLMissing the required parameter `body` when calling `get_aggregate_workspace`r   r   r   r    z</GetAggregateWorkspace/2021-03-03/vmp/post/application_json/r!   GetAggregateWorkspaceResponseTr#   r)   r4   s                  r   r   z-VMPApi.get_aggregate_workspace_with_http_info  r^   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_alert  # 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_alert(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetAlertRequest body: (required)
        :return: GetAlertResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   get_alert_with_http_infor   s       r   	get_alertzVMPApi.get_alert  s]     ,0'(::k"" 	040@@@@@2T24BB6BBTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  get_alert  # 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_alert_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetAlertRequest body: (required)
        :return: GetAlertResponse
                 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 get_alertNz>Missing the required parameter `body` when calling `get_alert`r   r   r   r    z//GetAlert/2021-03-03/vmp/post/application_json/r!   GetAlertResponseTr#   r)   r4   s                  r   r   zVMPApi.get_alert_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$+-01   F3KK8?1 	_vV7K7K7=f~7M]^^^V .K"&/"F"F #" #"h )-(R(R )" )"n% **''=v#!,'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_alerting_rule  # 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_alerting_rule(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetAlertingRuleRequest body: (required)
        :return: GetAlertingRuleResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r    get_alerting_rule_with_http_infor   s       r   get_alerting_rulezVMPApi.get_alerting_ruleD  ]     ,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
  get_alerting_rule  # 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_alerting_rule_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetAlertingRuleRequest body: (required)
        :return: GetAlertingRuleResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zCGot an unexpected keyword argument '%s' to method get_alerting_ruleNzFMissing the required parameter `body` when calling `get_alerting_rule`r   r   r   r    z6/GetAlertingRule/2021-03-03/vmp/post/application_json/r!   GetAlertingRuleResponseTr#   r)   r4   s                  r   r   z'VMPApi.get_alerting_rule_with_http_infoY      X
+&&&2333,---,---fX&677 	 	HC*$$3589   F3KK8?1 	gvV7K7K7=f~7MefffV .K"&/"F"F #" #"h )-(R(R )" )"n% **''Df#!3'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_contact  # 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_contact(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetContactRequest body: (required)
        :return: GetContactResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   get_contact_with_http_infor   s       r   get_contactzVMPApi.get_contact  ]     ,0'(::k"" 	2424BB6BBB4T4TDDVDDTKr   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  get_contact  # 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_contact_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetContactRequest body: (required)
        :return: GetContactResponse
                 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 get_contactNz@Missing the required parameter `body` when calling `get_contact`r   r   r   r    z1/GetContact/2021-03-03/vmp/post/application_json/r!   GetContactResponseTr#   r)   r4   s                  r   r   z!VMPApi.get_contact_with_http_info      X
+&&&2333,---,---fX&677 	 	HC*$$-/23   F3KK8?1 	avV7K7K7=f~7M_```V .K"&/"F"F #" #"h )-(R(R )" )"n% **''?#!.'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_contact_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.get_contact_group(body, async_req=True)
        >>> result = thread.get()

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

        :param async_req bool
        :param GetContactGroupRequest body: (required)
        :return: GetContactGroupResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zCGot an unexpected keyword argument '%s' to method get_contact_groupNzFMissing the required parameter `body` when calling `get_contact_group`r   r   r   r    z6/GetContactGroup/2021-03-03/vmp/post/application_json/r!   GetContactGroupResponseTr#   r)   r4   s                  r   r   z'VMPApi.get_contact_group_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_external_prometheus  # 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_external_prometheus(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetExternalPrometheusRequest body: (required)
        :return: GetExternalPrometheusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &get_external_prometheus_with_http_infor   s       r   get_external_prometheuszVMPApi.get_external_prometheusg  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_external_prometheus  # 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_external_prometheus_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetExternalPrometheusRequest body: (required)
        :return: GetExternalPrometheusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method get_external_prometheusNzLMissing the required parameter `body` when calling `get_external_prometheus`r   r   r   r    z</GetExternalPrometheus/2021-03-03/vmp/post/application_json/r!   GetExternalPrometheusResponseTr#   r)   r4   s                  r   r  z-VMPApi.get_external_prometheus_with_http_info|  r^   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_integration_task  # 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_integration_task(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetIntegrationTaskRequest body: (required)
        :return: GetIntegrationTaskResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #get_integration_task_with_http_infor   s       r   get_integration_taskzVMPApi.get_integration_task  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  get_integration_task  # 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_integration_task_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetIntegrationTaskRequest body: (required)
        :return: GetIntegrationTaskResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method get_integration_taskNzIMissing the required parameter `body` when calling `get_integration_task`r   r   r   r    z9/GetIntegrationTask/2021-03-03/vmp/post/application_json/r!   GetIntegrationTaskResponseTr#   r)   r4   s                  r   r  z*VMPApi.get_integration_task_with_http_info  rF   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_notify_group_policy  # noqa: E501

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

        :param async_req bool
        :param GetNotifyGroupPolicyRequest body: (required)
        :return: GetNotifyGroupPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &get_notify_group_policy_with_http_infor   s       r   get_notify_group_policyzVMPApi.get_notify_group_policy)  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_notify_group_policy  # noqa: E501

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

        :param async_req bool
        :param GetNotifyGroupPolicyRequest body: (required)
        :return: GetNotifyGroupPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method get_notify_group_policyNzLMissing the required parameter `body` when calling `get_notify_group_policy`r   r   r   r    z;/GetNotifyGroupPolicy/2021-03-03/vmp/post/application_json/r!   GetNotifyGroupPolicyResponseTr#   r)   r4   s                  r   r  z-VMPApi.get_notify_group_policy_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% **''I6#!8'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_notify_policy  # noqa: E501

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

        :param async_req bool
        :param GetNotifyPolicyRequest body: (required)
        :return: GetNotifyPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r    get_notify_policy_with_http_infor   s       r   get_notify_policyzVMPApi.get_notify_policy  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_notify_policy  # noqa: E501

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

        :param async_req bool
        :param GetNotifyPolicyRequest body: (required)
        :return: GetNotifyPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zCGot an unexpected keyword argument '%s' to method get_notify_policyNzFMissing the required parameter `body` when calling `get_notify_policy`r   r   r   r    z6/GetNotifyPolicy/2021-03-03/vmp/post/application_json/r!   GetNotifyPolicyResponseTr#   r)   r4   s                  r   r  z'VMPApi.get_notify_policy_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_rule_file  # 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_rule_file(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetRuleFileRequest body: (required)
        :return: GetRuleFileResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   get_rule_file_with_http_infor   s       r   get_rule_filezVMPApi.get_rule_file  ]     ,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  get_rule_file  # 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_rule_file_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetRuleFileRequest body: (required)
        :return: GetRuleFileResponse
                 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 get_rule_fileNzBMissing the required parameter `body` when calling `get_rule_file`r   r   r   r    z2/GetRuleFile/2021-03-03/vmp/post/application_json/r!   GetRuleFileResponseTr#   r)   r4   s                  r   r  z#VMPApi.get_rule_file_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% **''@&#!/'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  get_workspace  # 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_workspace(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetWorkspaceRequest body: (required)
        :return: GetWorkspaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   get_workspace_with_http_infor   s       r   get_workspacezVMPApi.get_workspaceL  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_workspace  # 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_workspace_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param GetWorkspaceRequest body: (required)
        :return: GetWorkspaceResponse
                 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 get_workspaceNzBMissing the required parameter `body` when calling `get_workspace`r   r   r   r    z3/GetWorkspace/2021-03-03/vmp/post/application_json/r!   GetWorkspaceResponseTr#   r)   r4   s                  r   r  z#VMPApi.get_workspace_with_http_infoa      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% **''A6#!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  get_workspace_auth_info  # noqa: E501

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

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

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

        :param async_req bool
        :param GetWorkspaceAuthInfoRequest body: (required)
        :return: GetWorkspaceAuthInfoResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method get_workspace_auth_infoNzLMissing the required parameter `body` when calling `get_workspace_auth_info`r   r   r   r    z;/GetWorkspaceAuthInfo/2021-03-03/vmp/post/application_json/r!   GetWorkspaceAuthInfoResponseTr#   r)   r4   s                  r   r"  z-VMPApi.get_workspace_auth_info_with_http_info  r  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_alert_samples  # noqa: E501

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

        :param async_req bool
        :param ListAlertSamplesRequest body: (required)
        :return: ListAlertSamplesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   !list_alert_samples_with_http_infor   s       r   list_alert_sampleszVMPApi.list_alert_samples  s]     ,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  list_alert_samples  # noqa: E501

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

        :param async_req bool
        :param ListAlertSamplesRequest body: (required)
        :return: ListAlertSamplesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zDGot an unexpected keyword argument '%s' to method list_alert_samplesNzGMissing the required parameter `body` when calling `list_alert_samples`r   r   r   r    z7/ListAlertSamples/2021-03-03/vmp/post/application_json/r!   ListAlertSamplesResponseTr#   r)   r4   s                  r   r'  z(VMPApi.list_alert_samples_with_http_info#  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% **''Ev#!4'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_alerting_rules  # noqa: E501

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

        :param async_req bool
        :param ListAlertingRulesRequest body: (required)
        :return: ListAlertingRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "list_alerting_rules_with_http_infor   s       r   list_alerting_ruleszVMPApi.list_alerting_ruleso  ]     ,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  list_alerting_rules  # noqa: E501

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

        :param async_req bool
        :param ListAlertingRulesRequest body: (required)
        :return: ListAlertingRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zEGot an unexpected keyword argument '%s' to method list_alerting_rulesNzHMissing the required parameter `body` when calling `list_alerting_rules`r   r   r   r    z8/ListAlertingRules/2021-03-03/vmp/post/application_json/r!   ListAlertingRulesResponseTr#   r)   r4   s                  r   r,  z)VMPApi.list_alerting_rules_with_http_info      X
+&&&2333,---,---fX&677 	 	HC*$$57:;   F3KK8?1 	ivV7K7K7=f~7MghhhV .K"&/"F"F #" #"h )-(R(R )" )"n% **''F#!5'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_alerts  # noqa: E501

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

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

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

        :param async_req bool
        :param ListAlertsRequest body: (required)
        :return: ListAlertsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z=Got an unexpected keyword argument '%s' to method list_alertsNz@Missing the required parameter `body` when calling `list_alerts`r   r   r   r    z1/ListAlerts/2021-03-03/vmp/post/application_json/r!   ListAlertsResponseTr#   r)   r4   s                  r   r3  z!VMPApi.list_alerts_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_contact_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.list_contact_groups(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListContactGroupsRequest body: (required)
        :return: ListContactGroupsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   "list_contact_groups_with_http_infor   s       r   list_contact_groupszVMPApi.list_contact_groups1  r.  r   c                 4   dg}|                     d           |                     d           |                     d           |                     d           t                      }t          j        |d                   D ] \  }}||vrt	          d|z            |||<   !|d= | j        j        rd|vs|d         t          d	          i }i }g }	i }
g }i }d}d|v r|d         }| j                            d
g          |
d<   | j        	                    d
g          |
d<   dg}| j        
                    dd||	|
|||d||                    d          |                    d          |                    dd          |                    d          |          S )a  list_contact_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.list_contact_groups_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ListContactGroupsRequest body: (required)
        :return: ListContactGroupsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zEGot an unexpected keyword argument '%s' to method list_contact_groupsNzHMissing the required parameter `body` when calling `list_contact_groups`r   r   r   r    z8/ListContactGroups/2021-03-03/vmp/post/application_json/r!   ListContactGroupsResponseTr#   r)   r4   s                  r   r8  z)VMPApi.list_contact_groups_with_http_infoF  r1  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_contacts  # noqa: E501

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

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

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

        :param async_req bool
        :param ListContactsRequest body: (required)
        :return: ListContactsResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z?Got an unexpected keyword argument '%s' to method list_contactsNzBMissing the required parameter `body` when calling `list_contacts`r   r   r   r    z3/ListContacts/2021-03-03/vmp/post/application_json/r!   ListContactsResponseTr#   r)   r4   s                  r   r=  z#VMPApi.list_contacts_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_integration_tasks  # noqa: E501

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

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

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

        :param async_req bool
        :param ListIntegrationTasksRequest body: (required)
        :return: ListIntegrationTasksResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method list_integration_tasksNzKMissing the required parameter `body` when calling `list_integration_tasks`r   r   r   r    z;/ListIntegrationTasks/2021-03-03/vmp/post/application_json/r!   ListIntegrationTasksResponseTr#   r)   r4   s                  r   rB  z,VMPApi.list_integration_tasks_with_http_info  rp   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_notify_group_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.list_notify_group_policies(body, async_req=True)
        >>> result = thread.get()

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

        :param async_req bool
        :param ListNotifyGroupPoliciesRequest body: (required)
        :return: ListNotifyGroupPoliciesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method list_notify_group_policiesNzOMissing the required parameter `body` when calling `list_notify_group_policies`r   r   r   r    z>/ListNotifyGroupPolicies/2021-03-03/vmp/post/application_json/r!   ListNotifyGroupPoliciesResponseTr#   r)   r4   s                  r   rG  z0VMPApi.list_notify_group_policies_with_http_infoi  rd   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_notify_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.list_notify_policies(body, async_req=True)
        >>> result = thread.get()

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

        :param async_req bool
        :param ListNotifyPoliciesRequest body: (required)
        :return: ListNotifyPoliciesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method list_notify_policiesNzIMissing the required parameter `body` when calling `list_notify_policies`r   r   r   r    z9/ListNotifyPolicies/2021-03-03/vmp/post/application_json/r!   ListNotifyPoliciesResponseTr#   r)   r4   s                  r   rL  z*VMPApi.list_notify_policies_with_http_info  rF   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_notify_templates  # noqa: E501

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

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

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

        :param async_req bool
        :param ListNotifyTemplatesRequest body: (required)
        :return: ListNotifyTemplatesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method list_notify_templatesNzJMissing the required parameter `body` when calling `list_notify_templates`r   r   r   r    z:/ListNotifyTemplates/2021-03-03/vmp/post/application_json/r!   ListNotifyTemplatesResponseTr#   r)   r4   s                  r   rQ  z+VMPApi.list_notify_templates_with_http_info+  r~   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_rule_files  # noqa: E501

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

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

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

        :param async_req bool
        :param ListRuleFilesRequest body: (required)
        :return: ListRuleFilesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zAGot an unexpected keyword argument '%s' to method list_rule_filesNzDMissing the required parameter `body` when calling `list_rule_files`r   r   r   r    z4/ListRuleFiles/2021-03-03/vmp/post/application_json/r!   ListRuleFilesResponseTr#   r)   r4   s                  r   rV  z%VMPApi.list_rule_files_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$1367   F3KK8?1 	evV7K7K7=f~7McdddV .K"&/"F"F #" #"h )-(R(R )" )"n% **''BF#!1'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_rules  # noqa: E501

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

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

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

        :param async_req bool
        :param ListRulesRequest body: (required)
        :return: ListRulesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z<Got an unexpected keyword argument '%s' to method list_rulesNz?Missing the required parameter `body` when calling `list_rules`r   r   r   r    z0/ListRules/2021-03-03/vmp/post/application_json/r!   ListRulesResponseTr#   r)   r4   s                  r   r[  z VMPApi.list_rules_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$,.12   F3KK8?1 	`vV7K7K7=f~7M^___V .K"&/"F"F #" #"h )-(R(R )" )"n% **''>#!-'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_silence_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.list_silence_policies(body, async_req=True)
        >>> result = thread.get()

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

        :param async_req bool
        :param ListSilencePoliciesRequest body: (required)
        :return: ListSilencePoliciesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method list_silence_policiesNzJMissing the required parameter `body` when calling `list_silence_policies`r   r   r   r    z:/ListSilencePolicies/2021-03-03/vmp/post/application_json/r!   ListSilencePoliciesResponseTr#   r)   r4   s                  r   r`  z+VMPApi.list_silence_policies_with_http_infoN  r~   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_tags_for_resources  # noqa: E501

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

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

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

        :param async_req bool
        :param ListTagsForResourcesRequest body: (required)
        :return: ListTagsForResourcesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method list_tags_for_resourcesNzLMissing the required parameter `body` when calling `list_tags_for_resources`r   r   r   r    z;/ListTagsForResources/2021-03-03/vmp/post/application_json/r!   ListTagsForResourcesResponseTr#   r)   r4   s                  r   re  z-VMPApi.list_tags_for_resources_with_http_info  r  r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a)  list_workspace_instance_types  # noqa: E501

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

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

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

        :param async_req bool
        :param ListWorkspaceInstanceTypesRequest body: (required)
        :return: ListWorkspaceInstanceTypesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zOGot an unexpected keyword argument '%s' to method list_workspace_instance_typesNzRMissing the required parameter `body` when calling `list_workspace_instance_types`r   r   r   r    zA/ListWorkspaceInstanceTypes/2021-03-03/vmp/post/application_json/r!   "ListWorkspaceInstanceTypesResponseTr#   r)   r4   s                  r   rj  z3VMPApi.list_workspace_instance_types_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$?ADE   F3KK8?1 	svV7K7K7=f~7MqrrrV .K"&/"F"F #" #"h )-(R(R )" )"n% **''OQW#!>'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_workspace_status  # noqa: E501

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

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

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

        :param async_req bool
        :param ListWorkspaceStatusRequest body: (required)
        :return: ListWorkspaceStatusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method list_workspace_statusNzJMissing the required parameter `body` when calling `list_workspace_status`r   r   r   r    z:/ListWorkspaceStatus/2021-03-03/vmp/post/application_json/r!   ListWorkspaceStatusResponseTr#   r)   r4   s                  r   ro  z+VMPApi.list_workspace_status_with_http_infoq  r~   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  list_workspaces  # noqa: E501

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

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

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

        :param async_req bool
        :param ListWorkspacesRequest body: (required)
        :return: ListWorkspacesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zAGot an unexpected keyword argument '%s' to method list_workspacesNzDMissing the required parameter `body` when calling `list_workspaces`r   r   r   r    z5/ListWorkspaces/2021-03-03/vmp/post/application_json/r!   ListWorkspacesResponseTr#   r)   r4   s                  r   rt  z%VMPApi.list_workspaces_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  send_validation_message  # noqa: E501

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

        :param async_req bool
        :param SendValidationMessageRequest body: (required)
        :return: SendValidationMessageResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &send_validation_message_with_http_infor   s       r   send_validation_messagezVMPApi.send_validation_message  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"  send_validation_message  # noqa: E501

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

        :param async_req bool
        :param SendValidationMessageRequest body: (required)
        :return: SendValidationMessageResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method send_validation_messageNzLMissing the required parameter `body` when calling `send_validation_message`r   r   r   r    z</SendValidationMessage/2021-03-03/vmp/post/application_json/r!   SendValidationMessageResponseTr#   r)   r4   s                  r   ry  z-VMPApi.send_validation_message_with_http_info3  r^   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  tag_resources  # noqa: E501

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

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

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

        :param async_req bool
        :param TagResourcesRequest body: (required)
        :return: TagResourcesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   z?Got an unexpected keyword argument '%s' to method tag_resourcesNzBMissing the required parameter `body` when calling `tag_resources`r   r   r   r    z3/TagResources/2021-03-03/vmp/post/application_json/r!   TagResourcesResponseTr#   r)   r4   s                  r   r~  z#VMPApi.tag_resources_with_http_info  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  test_ding_talk_bot_webhook  # noqa: E501

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

        :param async_req bool
        :param TestDingTalkBotWebhookRequest body: (required)
        :return: TestDingTalkBotWebhookResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   )test_ding_talk_bot_webhook_with_http_infor   s       r   test_ding_talk_bot_webhookz!VMPApi.test_ding_talk_bot_webhook  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*  test_ding_talk_bot_webhook  # noqa: E501

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

        :param async_req bool
        :param TestDingTalkBotWebhookRequest body: (required)
        :return: TestDingTalkBotWebhookResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method test_ding_talk_bot_webhookNzOMissing the required parameter `body` when calling `test_ding_talk_bot_webhook`r   r   r   r    z=/TestDingTalkBotWebhook/2021-03-03/vmp/post/application_json/r!   TestDingTalkBotWebhookResponseTr#   r)   r4   s                  r   r  z0VMPApi.test_ding_talk_bot_webhook_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$<>AB   F3KK8?1 	pvV7K7K7=f~7MnoooV .K"&/"F"F #" #"h )-(R(R )" )"n% **''KV#!:'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a	  test_lark_bot_webhook  # noqa: E501

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

        :param async_req bool
        :param TestLarkBotWebhookRequest body: (required)
        :return: TestLarkBotWebhookResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   $test_lark_bot_webhook_with_http_infor   s       r   test_lark_bot_webhookzVMPApi.test_lark_bot_webhookA  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  test_lark_bot_webhook  # noqa: E501

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

        :param async_req bool
        :param TestLarkBotWebhookRequest body: (required)
        :return: TestLarkBotWebhookResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method test_lark_bot_webhookNzJMissing the required parameter `body` when calling `test_lark_bot_webhook`r   r   r   r    z9/TestLarkBotWebhook/2021-03-03/vmp/post/application_json/r!   TestLarkBotWebhookResponseTr#   r)   r4   s                  r   r  z+VMPApi.test_lark_bot_webhook_with_http_infoV  s    X
+&&&2333,---,---fX&677 	 	HC*$$79<=   F3KK8?1 	kvV7K7K7=f~7MijjjV .K"&/"F"F #" #"h )-(R(R )" )"n% **''G#!6'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  test_we_com_bot_webhook  # noqa: E501

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

        :param async_req bool
        :param TestWeComBotWebhookRequest body: (required)
        :return: TestWeComBotWebhookResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   &test_we_com_bot_webhook_with_http_infor   s       r   test_we_com_bot_webhookzVMPApi.test_we_com_bot_webhook  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  test_we_com_bot_webhook  # noqa: E501

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

        :param async_req bool
        :param TestWeComBotWebhookRequest body: (required)
        :return: TestWeComBotWebhookResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method test_we_com_bot_webhookNzLMissing the required parameter `body` when calling `test_we_com_bot_webhook`r   r   r   r    z:/TestWeComBotWebhook/2021-03-03/vmp/post/application_json/r!   TestWeComBotWebhookResponseTr#   r)   r4   s                  r   r  z-VMPApi.test_we_com_bot_webhook_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$9;>?   F3KK8?1 	mvV7K7K7=f~7MklllV .K"&/"F"F #" #"h )-(R(R )" )"n% **''H&#!7'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  test_webhook  # noqa: E501

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

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

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

        :param async_req bool
        :param TestWebhookRequest body: (required)
        :return: TestWebhookResponse
                 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 test_webhookNzAMissing the required parameter `body` when calling `test_webhook`r   r   r   r    z2/TestWebhook/2021-03-03/vmp/post/application_json/r!   TestWebhookResponseTr#   r)   r4   s                  r   r  z"VMPApi.test_webhook_with_http_info  s    X
+&&&2333,---,---fX&677 	 	HC*$$.034   F3KK8?1 	bvV7K7K7=f~7M`aaaV .K"&/"F"F #" #"h )-(R(R )" )"n% **''@&#!/'jj--#)::.F#G#G#ZZ(:DAA#ZZ(:;;1 ( 3 3 	3r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  untag_resources  # noqa: E501

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

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

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

        :param async_req bool
        :param UntagResourcesRequest body: (required)
        :return: UntagResourcesResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zAGot an unexpected keyword argument '%s' to method untag_resourcesNzDMissing the required parameter `body` when calling `untag_resources`r   r   r   r    z5/UntagResources/2021-03-03/vmp/post/application_json/r!   UntagResourcesResponseTr#   r)   r4   s                  r   r  z%VMPApi.untag_resources_with_http_infoy  r   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  update_aggregate_workspace  # noqa: E501

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

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

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

        :param async_req bool
        :param UpdateAggregateWorkspaceRequest body: (required)
        :return: UpdateAggregateWorkspaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method update_aggregate_workspaceNzOMissing the required parameter `body` when calling `update_aggregate_workspace`r   r   r   r    z?/UpdateAggregateWorkspace/2021-03-03/vmp/post/application_json/r!    UpdateAggregateWorkspaceResponseTr#   r)   r4   s                  r   r  z0VMPApi.update_aggregate_workspace_with_http_info  r?   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  update_alerting_rule  # noqa: E501

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

        :param async_req bool
        :param UpdateAlertingRuleRequest body: (required)
        :return: UpdateAlertingRuleResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #update_alerting_rule_with_http_infor   s       r   update_alerting_rulezVMPApi.update_alerting_rule&  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  update_alerting_rule  # noqa: E501

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

        :param async_req bool
        :param UpdateAlertingRuleRequest body: (required)
        :return: UpdateAlertingRuleResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method update_alerting_ruleNzIMissing the required parameter `body` when calling `update_alerting_rule`r   r   r   r    z9/UpdateAlertingRule/2021-03-03/vmp/post/application_json/r!   UpdateAlertingRuleResponseTr#   r)   r4   s                  r   r  z*VMPApi.update_alerting_rule_with_http_info;  rF   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  update_contact  # noqa: E501

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

        :param async_req bool
        :param UpdateContactRequest body: (required)
        :return: UpdateContactResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   update_contact_with_http_infor   s       r   update_contactzVMPApi.update_contact  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   update_contact  # noqa: E501

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

        :param async_req bool
        :param UpdateContactRequest body: (required)
        :return: UpdateContactResponse
                 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 update_contactNzCMissing the required parameter `body` when calling `update_contact`r   r   r   r    z4/UpdateContact/2021-03-03/vmp/post/application_json/r!   UpdateContactResponseTr#   r)   r4   s                  r   r  z$VMPApi.update_contact_with_http_info  rM   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  update_contact_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.update_contact_group(body, async_req=True)
        >>> result = thread.get()

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

        :param async_req bool
        :param UpdateContactGroupRequest body: (required)
        :return: UpdateContactGroupResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method update_contact_groupNzIMissing the required parameter `body` when calling `update_contact_group`r   r   r   r    z9/UpdateContactGroup/2021-03-03/vmp/post/application_json/r!   UpdateContactGroupResponseTr#   r)   r4   s                  r   r  z*VMPApi.update_contact_group_with_http_info  rF   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  update_external_prometheus  # noqa: E501

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

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

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

        :param async_req bool
        :param UpdateExternalPrometheusRequest body: (required)
        :return: UpdateExternalPrometheusResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method update_external_prometheusNzOMissing the required parameter `body` when calling `update_external_prometheus`r   r   r   r    z?/UpdateExternalPrometheus/2021-03-03/vmp/post/application_json/r!    UpdateExternalPrometheusResponseTr#   r)   r4   s                  r   r  z0VMPApi.update_external_prometheus_with_http_info^  r?   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  update_integration_task  # noqa: E501

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

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

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

        :param async_req bool
        :param UpdateIntegrationTaskRequest body: (required)
        :return: UpdateIntegrationTaskResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zIGot an unexpected keyword argument '%s' to method update_integration_taskNzLMissing the required parameter `body` when calling `update_integration_task`r   r   r   r    z</UpdateIntegrationTask/2021-03-03/vmp/post/application_json/r!   UpdateIntegrationTaskResponseTr#   r)   r4   s                  r   r  z-VMPApi.update_integration_task_with_http_info  r^   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  update_notify_group_policy  # noqa: E501

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

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

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

        :param async_req bool
        :param UpdateNotifyGroupPolicyRequest body: (required)
        :return: UpdateNotifyGroupPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zLGot an unexpected keyword argument '%s' to method update_notify_group_policyNzOMissing the required parameter `body` when calling `update_notify_group_policy`r   r   r   r    z>/UpdateNotifyGroupPolicy/2021-03-03/vmp/post/application_json/r!   UpdateNotifyGroupPolicyResponseTr#   r)   r4   s                  r   r  z0VMPApi.update_notify_group_policy_with_http_info   rd   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  update_notify_policy  # noqa: E501

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

        :param async_req bool
        :param UpdateNotifyPolicyRequest body: (required)
        :return: UpdateNotifyPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        Tr   r   )r   #update_notify_policy_with_http_infor   s       r   update_notify_policyzVMPApi.update_notify_policyl  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  update_notify_policy  # noqa: E501

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

        :param async_req bool
        :param UpdateNotifyPolicyRequest body: (required)
        :return: UpdateNotifyPolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zFGot an unexpected keyword argument '%s' to method update_notify_policyNzIMissing the required parameter `body` when calling `update_notify_policy`r   r   r   r    z9/UpdateNotifyPolicy/2021-03-03/vmp/post/application_json/r!   UpdateNotifyPolicyResponseTr#   r)   r4   s                  r   r  z*VMPApi.update_notify_policy_with_http_info  rF   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  update_notify_template  # noqa: E501

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

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

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

        :param async_req bool
        :param UpdateNotifyTemplateRequest body: (required)
        :return: UpdateNotifyTemplateResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zHGot an unexpected keyword argument '%s' to method update_notify_templateNzKMissing the required parameter `body` when calling `update_notify_template`r   r   r   r    z;/UpdateNotifyTemplate/2021-03-03/vmp/post/application_json/r!   UpdateNotifyTemplateResponseTr#   r)   r4   s                  r   r  z,VMPApi.update_notify_template_with_http_info  rp   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  update_rule_file  # noqa: E501

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

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

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

        :param async_req bool
        :param UpdateRuleFileRequest body: (required)
        :return: UpdateRuleFileResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zBGot an unexpected keyword argument '%s' to method update_rule_fileNzEMissing the required parameter `body` when calling `update_rule_file`r   r   r   r    z5/UpdateRuleFile/2021-03-03/vmp/post/application_json/r!   UpdateRuleFileResponseTr#   r)   r4   s                  r   r  z&VMPApi.update_rule_file_with_http_infoC  rw   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  update_silence_policy  # noqa: E501

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

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

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

        :param async_req bool
        :param UpdateSilencePolicyRequest body: (required)
        :return: UpdateSilencePolicyResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zGGot an unexpected keyword argument '%s' to method update_silence_policyNzJMissing the required parameter `body` when calling `update_silence_policy`r   r   r   r    z:/UpdateSilencePolicy/2021-03-03/vmp/post/application_json/r!   UpdateSilencePolicyResponseTr#   r)   r4   s                  r   r  z+VMPApi.update_silence_policy_with_http_info  r~   r   c                 r    d|d<   |                     d          r | j        |fi |S  | j        |fi |}|S )a  update_workspace  # noqa: E501

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

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

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

        :param async_req bool
        :param UpdateWorkspaceRequest body: (required)
        :return: UpdateWorkspaceResponse
                 If the method is called asynchronously,
                 returns the request thread.
        r   r   r   r   r   r   zBGot an unexpected keyword argument '%s' to method update_workspaceNzEMissing the required parameter `body` when calling `update_workspace`r   r   r   r    z6/UpdateWorkspace/2021-03-03/vmp/post/application_json/r!   UpdateWorkspaceResponseTr#   r)   r4   s                  r   r  z&VMPApi.update_workspace_with_http_info  r   r   r   )__name__
__module____qualname____doc__r   r   r   rB   rA   rI   rH   rP   rO   rU   rT   rZ   rY   ra   r`   rg   rf   rl   rk   rs   rr   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   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,  r4  r3  r9  r8  r>  r=  rC  rB  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  r  r  r  r  r  r  r  r   r   r   r   r      sm
        % % % %
  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J3X  *J3 J3 J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     ' & & & & & 				 


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