@@ -47136,6 +47136,122 @@ def rotated_secret_create_mysql_with_http_info(self, rotated_secret_create_mysql
4713647136 _request_timeout=local_var_params.get('_request_timeout'),
4713747137 collection_formats=collection_formats)
4713847138
47139+ def rotated_secret_create_open_ai(self, rotated_secret_create_open_ai, **kwargs): # noqa: E501
47140+ """rotated_secret_create_open_ai # noqa: E501
47141+
47142+ This method makes a synchronous HTTP request by default. To make an
47143+ asynchronous HTTP request, please pass async_req=True
47144+ >>> thread = api.rotated_secret_create_open_ai(rotated_secret_create_open_ai, async_req=True)
47145+ >>> result = thread.get()
47146+
47147+ :param async_req bool: execute request asynchronously
47148+ :param RotatedSecretCreateOpenAI rotated_secret_create_open_ai: (required)
47149+ :param _preload_content: if False, the urllib3.HTTPResponse object will
47150+ be returned without reading/decoding response
47151+ data. Default is True.
47152+ :param _request_timeout: timeout setting for this request. If one
47153+ number provided, it will be total request
47154+ timeout. It can also be a pair (tuple) of
47155+ (connection, read) timeouts.
47156+ :return: RotatedSecretCreateOutput
47157+ If the method is called asynchronously,
47158+ returns the request thread.
47159+ """
47160+ kwargs['_return_http_data_only'] = True
47161+ return self.rotated_secret_create_open_ai_with_http_info(rotated_secret_create_open_ai, **kwargs) # noqa: E501
47162+
47163+ def rotated_secret_create_open_ai_with_http_info(self, rotated_secret_create_open_ai, **kwargs): # noqa: E501
47164+ """rotated_secret_create_open_ai # noqa: E501
47165+
47166+ This method makes a synchronous HTTP request by default. To make an
47167+ asynchronous HTTP request, please pass async_req=True
47168+ >>> thread = api.rotated_secret_create_open_ai_with_http_info(rotated_secret_create_open_ai, async_req=True)
47169+ >>> result = thread.get()
47170+
47171+ :param async_req bool: execute request asynchronously
47172+ :param RotatedSecretCreateOpenAI rotated_secret_create_open_ai: (required)
47173+ :param _return_http_data_only: response data without head status code
47174+ and headers
47175+ :param _preload_content: if False, the urllib3.HTTPResponse object will
47176+ be returned without reading/decoding response
47177+ data. Default is True.
47178+ :param _request_timeout: timeout setting for this request. If one
47179+ number provided, it will be total request
47180+ timeout. It can also be a pair (tuple) of
47181+ (connection, read) timeouts.
47182+ :return: tuple(RotatedSecretCreateOutput, status_code(int), headers(HTTPHeaderDict))
47183+ If the method is called asynchronously,
47184+ returns the request thread.
47185+ """
47186+
47187+ local_var_params = locals()
47188+
47189+ all_params = [
47190+ 'rotated_secret_create_open_ai'
47191+ ]
47192+ all_params.extend(
47193+ [
47194+ 'async_req',
47195+ '_return_http_data_only',
47196+ '_preload_content',
47197+ '_request_timeout'
47198+ ]
47199+ )
47200+
47201+ for key, val in six.iteritems(local_var_params['kwargs']):
47202+ if key not in all_params:
47203+ raise ApiTypeError(
47204+ "Got an unexpected keyword argument '%s'"
47205+ " to method rotated_secret_create_open_ai" % key
47206+ )
47207+ local_var_params[key] = val
47208+ del local_var_params['kwargs']
47209+ # verify the required parameter 'rotated_secret_create_open_ai' is set
47210+ if self.api_client.client_side_validation and ('rotated_secret_create_open_ai' not in local_var_params or # noqa: E501
47211+ local_var_params['rotated_secret_create_open_ai'] is None): # noqa: E501
47212+ raise ApiValueError("Missing the required parameter `rotated_secret_create_open_ai` when calling `rotated_secret_create_open_ai`") # noqa: E501
47213+
47214+ collection_formats = {}
47215+
47216+ path_params = {}
47217+
47218+ query_params = []
47219+
47220+ header_params = {}
47221+
47222+ form_params = []
47223+ local_var_files = {}
47224+
47225+ body_params = None
47226+ if 'rotated_secret_create_open_ai' in local_var_params:
47227+ body_params = local_var_params['rotated_secret_create_open_ai']
47228+ # HTTP header `Accept`
47229+ header_params['Accept'] = self.api_client.select_header_accept(
47230+ ['application/json']) # noqa: E501
47231+
47232+ # HTTP header `Content-Type`
47233+ header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
47234+ ['application/json']) # noqa: E501
47235+
47236+ # Authentication setting
47237+ auth_settings = [] # noqa: E501
47238+
47239+ return self.api_client.call_api(
47240+ '/rotated-secret-create-openai', 'POST',
47241+ path_params,
47242+ query_params,
47243+ header_params,
47244+ body=body_params,
47245+ post_params=form_params,
47246+ files=local_var_files,
47247+ response_type='RotatedSecretCreateOutput', # noqa: E501
47248+ auth_settings=auth_settings,
47249+ async_req=local_var_params.get('async_req'),
47250+ _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
47251+ _preload_content=local_var_params.get('_preload_content', True),
47252+ _request_timeout=local_var_params.get('_request_timeout'),
47253+ collection_formats=collection_formats)
47254+
4713947255 def rotated_secret_create_oracledb(self, rotated_secret_create_oracledb, **kwargs): # noqa: E501
4714047256 """rotated_secret_create_oracledb # noqa: E501
4714147257
@@ -49804,6 +49920,122 @@ def rotated_secret_update_mysql_with_http_info(self, rotated_secret_update_mysql
4980449920 _request_timeout=local_var_params.get('_request_timeout'),
4980549921 collection_formats=collection_formats)
4980649922
49923+ def rotated_secret_update_open_ai(self, rotated_secret_update_open_ai, **kwargs): # noqa: E501
49924+ """rotated_secret_update_open_ai # noqa: E501
49925+
49926+ This method makes a synchronous HTTP request by default. To make an
49927+ asynchronous HTTP request, please pass async_req=True
49928+ >>> thread = api.rotated_secret_update_open_ai(rotated_secret_update_open_ai, async_req=True)
49929+ >>> result = thread.get()
49930+
49931+ :param async_req bool: execute request asynchronously
49932+ :param RotatedSecretUpdateOpenAI rotated_secret_update_open_ai: (required)
49933+ :param _preload_content: if False, the urllib3.HTTPResponse object will
49934+ be returned without reading/decoding response
49935+ data. Default is True.
49936+ :param _request_timeout: timeout setting for this request. If one
49937+ number provided, it will be total request
49938+ timeout. It can also be a pair (tuple) of
49939+ (connection, read) timeouts.
49940+ :return: RotatedSecretUpdateOutput
49941+ If the method is called asynchronously,
49942+ returns the request thread.
49943+ """
49944+ kwargs['_return_http_data_only'] = True
49945+ return self.rotated_secret_update_open_ai_with_http_info(rotated_secret_update_open_ai, **kwargs) # noqa: E501
49946+
49947+ def rotated_secret_update_open_ai_with_http_info(self, rotated_secret_update_open_ai, **kwargs): # noqa: E501
49948+ """rotated_secret_update_open_ai # noqa: E501
49949+
49950+ This method makes a synchronous HTTP request by default. To make an
49951+ asynchronous HTTP request, please pass async_req=True
49952+ >>> thread = api.rotated_secret_update_open_ai_with_http_info(rotated_secret_update_open_ai, async_req=True)
49953+ >>> result = thread.get()
49954+
49955+ :param async_req bool: execute request asynchronously
49956+ :param RotatedSecretUpdateOpenAI rotated_secret_update_open_ai: (required)
49957+ :param _return_http_data_only: response data without head status code
49958+ and headers
49959+ :param _preload_content: if False, the urllib3.HTTPResponse object will
49960+ be returned without reading/decoding response
49961+ data. Default is True.
49962+ :param _request_timeout: timeout setting for this request. If one
49963+ number provided, it will be total request
49964+ timeout. It can also be a pair (tuple) of
49965+ (connection, read) timeouts.
49966+ :return: tuple(RotatedSecretUpdateOutput, status_code(int), headers(HTTPHeaderDict))
49967+ If the method is called asynchronously,
49968+ returns the request thread.
49969+ """
49970+
49971+ local_var_params = locals()
49972+
49973+ all_params = [
49974+ 'rotated_secret_update_open_ai'
49975+ ]
49976+ all_params.extend(
49977+ [
49978+ 'async_req',
49979+ '_return_http_data_only',
49980+ '_preload_content',
49981+ '_request_timeout'
49982+ ]
49983+ )
49984+
49985+ for key, val in six.iteritems(local_var_params['kwargs']):
49986+ if key not in all_params:
49987+ raise ApiTypeError(
49988+ "Got an unexpected keyword argument '%s'"
49989+ " to method rotated_secret_update_open_ai" % key
49990+ )
49991+ local_var_params[key] = val
49992+ del local_var_params['kwargs']
49993+ # verify the required parameter 'rotated_secret_update_open_ai' is set
49994+ if self.api_client.client_side_validation and ('rotated_secret_update_open_ai' not in local_var_params or # noqa: E501
49995+ local_var_params['rotated_secret_update_open_ai'] is None): # noqa: E501
49996+ raise ApiValueError("Missing the required parameter `rotated_secret_update_open_ai` when calling `rotated_secret_update_open_ai`") # noqa: E501
49997+
49998+ collection_formats = {}
49999+
50000+ path_params = {}
50001+
50002+ query_params = []
50003+
50004+ header_params = {}
50005+
50006+ form_params = []
50007+ local_var_files = {}
50008+
50009+ body_params = None
50010+ if 'rotated_secret_update_open_ai' in local_var_params:
50011+ body_params = local_var_params['rotated_secret_update_open_ai']
50012+ # HTTP header `Accept`
50013+ header_params['Accept'] = self.api_client.select_header_accept(
50014+ ['application/json']) # noqa: E501
50015+
50016+ # HTTP header `Content-Type`
50017+ header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
50018+ ['application/json']) # noqa: E501
50019+
50020+ # Authentication setting
50021+ auth_settings = [] # noqa: E501
50022+
50023+ return self.api_client.call_api(
50024+ '/rotated-secret-update-openai', 'POST',
50025+ path_params,
50026+ query_params,
50027+ header_params,
50028+ body=body_params,
50029+ post_params=form_params,
50030+ files=local_var_files,
50031+ response_type='RotatedSecretUpdateOutput', # noqa: E501
50032+ auth_settings=auth_settings,
50033+ async_req=local_var_params.get('async_req'),
50034+ _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
50035+ _preload_content=local_var_params.get('_preload_content', True),
50036+ _request_timeout=local_var_params.get('_request_timeout'),
50037+ collection_formats=collection_formats)
50038+
4980750039 def rotated_secret_update_oracledb(self, rotated_secret_update_oracledb, **kwargs): # noqa: E501
4980850040 """rotated_secret_update_oracledb # noqa: E501
4980950041
0 commit comments