@@ -10477,6 +10477,122 @@ def decrypt_with_http_info(self, body, **kwargs): # noqa: E501
1047710477 _request_timeout=local_var_params.get('_request_timeout'),
1047810478 collection_formats=collection_formats)
1047910479
10480+ def decrypt_batch(self, body, **kwargs): # noqa: E501
10481+ """decrypt_batch # noqa: E501
10482+
10483+ This method makes a synchronous HTTP request by default. To make an
10484+ asynchronous HTTP request, please pass async_req=True
10485+ >>> thread = api.decrypt_batch(body, async_req=True)
10486+ >>> result = thread.get()
10487+
10488+ :param async_req bool: execute request asynchronously
10489+ :param list[BatchEncryptionRequestLine] body: (required)
10490+ :param _preload_content: if False, the urllib3.HTTPResponse object will
10491+ be returned without reading/decoding response
10492+ data. Default is True.
10493+ :param _request_timeout: timeout setting for this request. If one
10494+ number provided, it will be total request
10495+ timeout. It can also be a pair (tuple) of
10496+ (connection, read) timeouts.
10497+ :return: DecryptOutput
10498+ If the method is called asynchronously,
10499+ returns the request thread.
10500+ """
10501+ kwargs['_return_http_data_only'] = True
10502+ return self.decrypt_batch_with_http_info(body, **kwargs) # noqa: E501
10503+
10504+ def decrypt_batch_with_http_info(self, body, **kwargs): # noqa: E501
10505+ """decrypt_batch # noqa: E501
10506+
10507+ This method makes a synchronous HTTP request by default. To make an
10508+ asynchronous HTTP request, please pass async_req=True
10509+ >>> thread = api.decrypt_batch_with_http_info(body, async_req=True)
10510+ >>> result = thread.get()
10511+
10512+ :param async_req bool: execute request asynchronously
10513+ :param list[BatchEncryptionRequestLine] body: (required)
10514+ :param _return_http_data_only: response data without head status code
10515+ and headers
10516+ :param _preload_content: if False, the urllib3.HTTPResponse object will
10517+ be returned without reading/decoding response
10518+ data. Default is True.
10519+ :param _request_timeout: timeout setting for this request. If one
10520+ number provided, it will be total request
10521+ timeout. It can also be a pair (tuple) of
10522+ (connection, read) timeouts.
10523+ :return: tuple(DecryptOutput, status_code(int), headers(HTTPHeaderDict))
10524+ If the method is called asynchronously,
10525+ returns the request thread.
10526+ """
10527+
10528+ local_var_params = locals()
10529+
10530+ all_params = [
10531+ 'body'
10532+ ]
10533+ all_params.extend(
10534+ [
10535+ 'async_req',
10536+ '_return_http_data_only',
10537+ '_preload_content',
10538+ '_request_timeout'
10539+ ]
10540+ )
10541+
10542+ for key, val in six.iteritems(local_var_params['kwargs']):
10543+ if key not in all_params:
10544+ raise ApiTypeError(
10545+ "Got an unexpected keyword argument '%s'"
10546+ " to method decrypt_batch" % key
10547+ )
10548+ local_var_params[key] = val
10549+ del local_var_params['kwargs']
10550+ # verify the required parameter 'body' is set
10551+ if self.api_client.client_side_validation and ('body' not in local_var_params or # noqa: E501
10552+ local_var_params['body'] is None): # noqa: E501
10553+ raise ApiValueError("Missing the required parameter `body` when calling `decrypt_batch`") # noqa: E501
10554+
10555+ collection_formats = {}
10556+
10557+ path_params = {}
10558+
10559+ query_params = []
10560+
10561+ header_params = {}
10562+
10563+ form_params = []
10564+ local_var_files = {}
10565+
10566+ body_params = None
10567+ if 'body' in local_var_params:
10568+ body_params = local_var_params['body']
10569+ # HTTP header `Accept`
10570+ header_params['Accept'] = self.api_client.select_header_accept(
10571+ ['application/json']) # noqa: E501
10572+
10573+ # HTTP header `Content-Type`
10574+ header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
10575+ ['application/json']) # noqa: E501
10576+
10577+ # Authentication setting
10578+ auth_settings = [] # noqa: E501
10579+
10580+ return self.api_client.call_api(
10581+ '/decrypt-batch', 'POST',
10582+ path_params,
10583+ query_params,
10584+ header_params,
10585+ body=body_params,
10586+ post_params=form_params,
10587+ files=local_var_files,
10588+ response_type='DecryptOutput', # noqa: E501
10589+ auth_settings=auth_settings,
10590+ async_req=local_var_params.get('async_req'),
10591+ _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
10592+ _preload_content=local_var_params.get('_preload_content', True),
10593+ _request_timeout=local_var_params.get('_request_timeout'),
10594+ collection_formats=collection_formats)
10595+
1048010596 def decrypt_gpg(self, body, **kwargs): # noqa: E501
1048110597 """decrypt_gpg # noqa: E501
1048210598
@@ -20445,6 +20561,122 @@ def encrypt_with_http_info(self, body, **kwargs): # noqa: E501
2044520561 _request_timeout=local_var_params.get('_request_timeout'),
2044620562 collection_formats=collection_formats)
2044720563
20564+ def encrypt_batch(self, body, **kwargs): # noqa: E501
20565+ """encrypt_batch # noqa: E501
20566+
20567+ This method makes a synchronous HTTP request by default. To make an
20568+ asynchronous HTTP request, please pass async_req=True
20569+ >>> thread = api.encrypt_batch(body, async_req=True)
20570+ >>> result = thread.get()
20571+
20572+ :param async_req bool: execute request asynchronously
20573+ :param list[BatchEncryptionRequestLine] body: (required)
20574+ :param _preload_content: if False, the urllib3.HTTPResponse object will
20575+ be returned without reading/decoding response
20576+ data. Default is True.
20577+ :param _request_timeout: timeout setting for this request. If one
20578+ number provided, it will be total request
20579+ timeout. It can also be a pair (tuple) of
20580+ (connection, read) timeouts.
20581+ :return: EncryptOutput
20582+ If the method is called asynchronously,
20583+ returns the request thread.
20584+ """
20585+ kwargs['_return_http_data_only'] = True
20586+ return self.encrypt_batch_with_http_info(body, **kwargs) # noqa: E501
20587+
20588+ def encrypt_batch_with_http_info(self, body, **kwargs): # noqa: E501
20589+ """encrypt_batch # noqa: E501
20590+
20591+ This method makes a synchronous HTTP request by default. To make an
20592+ asynchronous HTTP request, please pass async_req=True
20593+ >>> thread = api.encrypt_batch_with_http_info(body, async_req=True)
20594+ >>> result = thread.get()
20595+
20596+ :param async_req bool: execute request asynchronously
20597+ :param list[BatchEncryptionRequestLine] body: (required)
20598+ :param _return_http_data_only: response data without head status code
20599+ and headers
20600+ :param _preload_content: if False, the urllib3.HTTPResponse object will
20601+ be returned without reading/decoding response
20602+ data. Default is True.
20603+ :param _request_timeout: timeout setting for this request. If one
20604+ number provided, it will be total request
20605+ timeout. It can also be a pair (tuple) of
20606+ (connection, read) timeouts.
20607+ :return: tuple(EncryptOutput, status_code(int), headers(HTTPHeaderDict))
20608+ If the method is called asynchronously,
20609+ returns the request thread.
20610+ """
20611+
20612+ local_var_params = locals()
20613+
20614+ all_params = [
20615+ 'body'
20616+ ]
20617+ all_params.extend(
20618+ [
20619+ 'async_req',
20620+ '_return_http_data_only',
20621+ '_preload_content',
20622+ '_request_timeout'
20623+ ]
20624+ )
20625+
20626+ for key, val in six.iteritems(local_var_params['kwargs']):
20627+ if key not in all_params:
20628+ raise ApiTypeError(
20629+ "Got an unexpected keyword argument '%s'"
20630+ " to method encrypt_batch" % key
20631+ )
20632+ local_var_params[key] = val
20633+ del local_var_params['kwargs']
20634+ # verify the required parameter 'body' is set
20635+ if self.api_client.client_side_validation and ('body' not in local_var_params or # noqa: E501
20636+ local_var_params['body'] is None): # noqa: E501
20637+ raise ApiValueError("Missing the required parameter `body` when calling `encrypt_batch`") # noqa: E501
20638+
20639+ collection_formats = {}
20640+
20641+ path_params = {}
20642+
20643+ query_params = []
20644+
20645+ header_params = {}
20646+
20647+ form_params = []
20648+ local_var_files = {}
20649+
20650+ body_params = None
20651+ if 'body' in local_var_params:
20652+ body_params = local_var_params['body']
20653+ # HTTP header `Accept`
20654+ header_params['Accept'] = self.api_client.select_header_accept(
20655+ ['application/json']) # noqa: E501
20656+
20657+ # HTTP header `Content-Type`
20658+ header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
20659+ ['application/json']) # noqa: E501
20660+
20661+ # Authentication setting
20662+ auth_settings = [] # noqa: E501
20663+
20664+ return self.api_client.call_api(
20665+ '/encrypt-batch', 'POST',
20666+ path_params,
20667+ query_params,
20668+ header_params,
20669+ body=body_params,
20670+ post_params=form_params,
20671+ files=local_var_files,
20672+ response_type='EncryptOutput', # noqa: E501
20673+ auth_settings=auth_settings,
20674+ async_req=local_var_params.get('async_req'),
20675+ _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
20676+ _preload_content=local_var_params.get('_preload_content', True),
20677+ _request_timeout=local_var_params.get('_request_timeout'),
20678+ collection_formats=collection_formats)
20679+
2044820680 def encrypt_gpg(self, body, **kwargs): # noqa: E501
2044920681 """encrypt_gpg # noqa: E501
2045020682
0 commit comments