@@ -324,6 +324,103 @@ def create_default_node_pool_with_http_info(self, body, **kwargs): # noqa: E501
324324 _request_timeout = params .get ('_request_timeout' ),
325325 collection_formats = collection_formats )
326326
327+ def create_kubeconfig (self , body , ** kwargs ): # noqa: E501
328+ """create_kubeconfig # noqa: E501
329+
330+ This method makes a synchronous HTTP request by default. To make an
331+ asynchronous HTTP request, please pass async_req=True
332+ >>> thread = api.create_kubeconfig(body, async_req=True)
333+ >>> result = thread.get()
334+
335+ :param async_req bool
336+ :param CreateKubeconfigRequest body: (required)
337+ :return: CreateKubeconfigResponse
338+ If the method is called asynchronously,
339+ returns the request thread.
340+ """
341+ kwargs ['_return_http_data_only' ] = True
342+ if kwargs .get ('async_req' ):
343+ return self .create_kubeconfig_with_http_info (body , ** kwargs ) # noqa: E501
344+ else :
345+ (data ) = self .create_kubeconfig_with_http_info (body , ** kwargs ) # noqa: E501
346+ return data
347+
348+ def create_kubeconfig_with_http_info (self , body , ** kwargs ): # noqa: E501
349+ """create_kubeconfig # noqa: E501
350+
351+ This method makes a synchronous HTTP request by default. To make an
352+ asynchronous HTTP request, please pass async_req=True
353+ >>> thread = api.create_kubeconfig_with_http_info(body, async_req=True)
354+ >>> result = thread.get()
355+
356+ :param async_req bool
357+ :param CreateKubeconfigRequest body: (required)
358+ :return: CreateKubeconfigResponse
359+ If the method is called asynchronously,
360+ returns the request thread.
361+ """
362+
363+ all_params = ['body' ] # noqa: E501
364+ all_params .append ('async_req' )
365+ all_params .append ('_return_http_data_only' )
366+ all_params .append ('_preload_content' )
367+ all_params .append ('_request_timeout' )
368+
369+ params = locals ()
370+ for key , val in six .iteritems (params ['kwargs' ]):
371+ if key not in all_params :
372+ raise TypeError (
373+ "Got an unexpected keyword argument '%s'"
374+ " to method create_kubeconfig" % key
375+ )
376+ params [key ] = val
377+ del params ['kwargs' ]
378+ # verify the required parameter 'body' is set
379+ if self .api_client .client_side_validation and ('body' not in params or
380+ params ['body' ] is None ): # noqa: E501
381+ raise ValueError ("Missing the required parameter `body` when calling `create_kubeconfig`" ) # noqa: E501
382+
383+ collection_formats = {}
384+
385+ path_params = {}
386+
387+ query_params = []
388+
389+ header_params = {}
390+
391+ form_params = []
392+ local_var_files = {}
393+
394+ body_params = None
395+ if 'body' in params :
396+ body_params = params ['body' ]
397+ # HTTP header `Accept`
398+ header_params ['Accept' ] = self .api_client .select_header_accept (
399+ ['application/json' ]) # noqa: E501
400+
401+ # HTTP header `Content-Type`
402+ header_params ['Content-Type' ] = self .api_client .select_header_content_type ( # noqa: E501
403+ ['application/json' ]) # noqa: E501
404+
405+ # Authentication setting
406+ auth_settings = ['volcengineSign' ] # noqa: E501
407+
408+ return self .api_client .call_api (
409+ '/CreateKubeconfig/2022-05-12/vke/post/' , 'POST' ,
410+ path_params ,
411+ query_params ,
412+ header_params ,
413+ body = body_params ,
414+ post_params = form_params ,
415+ files = local_var_files ,
416+ response_type = 'CreateKubeconfigResponse' , # noqa: E501
417+ auth_settings = auth_settings ,
418+ async_req = params .get ('async_req' ),
419+ _return_http_data_only = params .get ('_return_http_data_only' ),
420+ _preload_content = params .get ('_preload_content' , True ),
421+ _request_timeout = params .get ('_request_timeout' ),
422+ collection_formats = collection_formats )
423+
327424 def create_node_pool (self , body , ** kwargs ): # noqa: E501
328425 """create_node_pool # noqa: E501
329426
@@ -712,6 +809,103 @@ def delete_cluster_with_http_info(self, body, **kwargs): # noqa: E501
712809 _request_timeout = params .get ('_request_timeout' ),
713810 collection_formats = collection_formats )
714811
812+ def delete_kubeconfigs (self , body , ** kwargs ): # noqa: E501
813+ """delete_kubeconfigs # noqa: E501
814+
815+ This method makes a synchronous HTTP request by default. To make an
816+ asynchronous HTTP request, please pass async_req=True
817+ >>> thread = api.delete_kubeconfigs(body, async_req=True)
818+ >>> result = thread.get()
819+
820+ :param async_req bool
821+ :param DeleteKubeconfigsRequest body: (required)
822+ :return: DeleteKubeconfigsResponse
823+ If the method is called asynchronously,
824+ returns the request thread.
825+ """
826+ kwargs ['_return_http_data_only' ] = True
827+ if kwargs .get ('async_req' ):
828+ return self .delete_kubeconfigs_with_http_info (body , ** kwargs ) # noqa: E501
829+ else :
830+ (data ) = self .delete_kubeconfigs_with_http_info (body , ** kwargs ) # noqa: E501
831+ return data
832+
833+ def delete_kubeconfigs_with_http_info (self , body , ** kwargs ): # noqa: E501
834+ """delete_kubeconfigs # noqa: E501
835+
836+ This method makes a synchronous HTTP request by default. To make an
837+ asynchronous HTTP request, please pass async_req=True
838+ >>> thread = api.delete_kubeconfigs_with_http_info(body, async_req=True)
839+ >>> result = thread.get()
840+
841+ :param async_req bool
842+ :param DeleteKubeconfigsRequest body: (required)
843+ :return: DeleteKubeconfigsResponse
844+ If the method is called asynchronously,
845+ returns the request thread.
846+ """
847+
848+ all_params = ['body' ] # noqa: E501
849+ all_params .append ('async_req' )
850+ all_params .append ('_return_http_data_only' )
851+ all_params .append ('_preload_content' )
852+ all_params .append ('_request_timeout' )
853+
854+ params = locals ()
855+ for key , val in six .iteritems (params ['kwargs' ]):
856+ if key not in all_params :
857+ raise TypeError (
858+ "Got an unexpected keyword argument '%s'"
859+ " to method delete_kubeconfigs" % key
860+ )
861+ params [key ] = val
862+ del params ['kwargs' ]
863+ # verify the required parameter 'body' is set
864+ if self .api_client .client_side_validation and ('body' not in params or
865+ params ['body' ] is None ): # noqa: E501
866+ raise ValueError ("Missing the required parameter `body` when calling `delete_kubeconfigs`" ) # noqa: E501
867+
868+ collection_formats = {}
869+
870+ path_params = {}
871+
872+ query_params = []
873+
874+ header_params = {}
875+
876+ form_params = []
877+ local_var_files = {}
878+
879+ body_params = None
880+ if 'body' in params :
881+ body_params = params ['body' ]
882+ # HTTP header `Accept`
883+ header_params ['Accept' ] = self .api_client .select_header_accept (
884+ ['application/json' ]) # noqa: E501
885+
886+ # HTTP header `Content-Type`
887+ header_params ['Content-Type' ] = self .api_client .select_header_content_type ( # noqa: E501
888+ ['application/json' ]) # noqa: E501
889+
890+ # Authentication setting
891+ auth_settings = ['volcengineSign' ] # noqa: E501
892+
893+ return self .api_client .call_api (
894+ '/DeleteKubeconfigs/2022-05-12/vke/post/' , 'POST' ,
895+ path_params ,
896+ query_params ,
897+ header_params ,
898+ body = body_params ,
899+ post_params = form_params ,
900+ files = local_var_files ,
901+ response_type = 'DeleteKubeconfigsResponse' , # noqa: E501
902+ auth_settings = auth_settings ,
903+ async_req = params .get ('async_req' ),
904+ _return_http_data_only = params .get ('_return_http_data_only' ),
905+ _preload_content = params .get ('_preload_content' , True ),
906+ _request_timeout = params .get ('_request_timeout' ),
907+ collection_formats = collection_formats )
908+
715909 def delete_node_pool (self , body , ** kwargs ): # noqa: E501
716910 """delete_node_pool # noqa: E501
717911
@@ -1197,6 +1391,103 @@ def list_clusters_with_http_info(self, body, **kwargs): # noqa: E501
11971391 _request_timeout = params .get ('_request_timeout' ),
11981392 collection_formats = collection_formats )
11991393
1394+ def list_kubeconfigs (self , body , ** kwargs ): # noqa: E501
1395+ """list_kubeconfigs # noqa: E501
1396+
1397+ This method makes a synchronous HTTP request by default. To make an
1398+ asynchronous HTTP request, please pass async_req=True
1399+ >>> thread = api.list_kubeconfigs(body, async_req=True)
1400+ >>> result = thread.get()
1401+
1402+ :param async_req bool
1403+ :param ListKubeconfigsRequest body: (required)
1404+ :return: ListKubeconfigsResponse
1405+ If the method is called asynchronously,
1406+ returns the request thread.
1407+ """
1408+ kwargs ['_return_http_data_only' ] = True
1409+ if kwargs .get ('async_req' ):
1410+ return self .list_kubeconfigs_with_http_info (body , ** kwargs ) # noqa: E501
1411+ else :
1412+ (data ) = self .list_kubeconfigs_with_http_info (body , ** kwargs ) # noqa: E501
1413+ return data
1414+
1415+ def list_kubeconfigs_with_http_info (self , body , ** kwargs ): # noqa: E501
1416+ """list_kubeconfigs # noqa: E501
1417+
1418+ This method makes a synchronous HTTP request by default. To make an
1419+ asynchronous HTTP request, please pass async_req=True
1420+ >>> thread = api.list_kubeconfigs_with_http_info(body, async_req=True)
1421+ >>> result = thread.get()
1422+
1423+ :param async_req bool
1424+ :param ListKubeconfigsRequest body: (required)
1425+ :return: ListKubeconfigsResponse
1426+ If the method is called asynchronously,
1427+ returns the request thread.
1428+ """
1429+
1430+ all_params = ['body' ] # noqa: E501
1431+ all_params .append ('async_req' )
1432+ all_params .append ('_return_http_data_only' )
1433+ all_params .append ('_preload_content' )
1434+ all_params .append ('_request_timeout' )
1435+
1436+ params = locals ()
1437+ for key , val in six .iteritems (params ['kwargs' ]):
1438+ if key not in all_params :
1439+ raise TypeError (
1440+ "Got an unexpected keyword argument '%s'"
1441+ " to method list_kubeconfigs" % key
1442+ )
1443+ params [key ] = val
1444+ del params ['kwargs' ]
1445+ # verify the required parameter 'body' is set
1446+ if self .api_client .client_side_validation and ('body' not in params or
1447+ params ['body' ] is None ): # noqa: E501
1448+ raise ValueError ("Missing the required parameter `body` when calling `list_kubeconfigs`" ) # noqa: E501
1449+
1450+ collection_formats = {}
1451+
1452+ path_params = {}
1453+
1454+ query_params = []
1455+
1456+ header_params = {}
1457+
1458+ form_params = []
1459+ local_var_files = {}
1460+
1461+ body_params = None
1462+ if 'body' in params :
1463+ body_params = params ['body' ]
1464+ # HTTP header `Accept`
1465+ header_params ['Accept' ] = self .api_client .select_header_accept (
1466+ ['application/json' ]) # noqa: E501
1467+
1468+ # HTTP header `Content-Type`
1469+ header_params ['Content-Type' ] = self .api_client .select_header_content_type ( # noqa: E501
1470+ ['application/json' ]) # noqa: E501
1471+
1472+ # Authentication setting
1473+ auth_settings = ['volcengineSign' ] # noqa: E501
1474+
1475+ return self .api_client .call_api (
1476+ '/ListKubeconfigs/2022-05-12/vke/post/' , 'POST' ,
1477+ path_params ,
1478+ query_params ,
1479+ header_params ,
1480+ body = body_params ,
1481+ post_params = form_params ,
1482+ files = local_var_files ,
1483+ response_type = 'ListKubeconfigsResponse' , # noqa: E501
1484+ auth_settings = auth_settings ,
1485+ async_req = params .get ('async_req' ),
1486+ _return_http_data_only = params .get ('_return_http_data_only' ),
1487+ _preload_content = params .get ('_preload_content' , True ),
1488+ _request_timeout = params .get ('_request_timeout' ),
1489+ collection_formats = collection_formats )
1490+
12001491 def list_node_pools (self , body , ** kwargs ): # noqa: E501
12011492 """list_node_pools # noqa: E501
12021493
0 commit comments