@@ -518,6 +518,103 @@ def delete_custom_route_with_http_info(self, body, **kwargs): # noqa: E501
518518 _request_timeout = params .get ('_request_timeout' ),
519519 collection_formats = collection_formats )
520520
521+ def list_app (self , body , ** kwargs ): # noqa: E501
522+ """list_app # noqa: E501
523+
524+ This method makes a synchronous HTTP request by default. To make an
525+ asynchronous HTTP request, please pass async_req=True
526+ >>> thread = api.list_app(body, async_req=True)
527+ >>> result = thread.get()
528+
529+ :param async_req bool
530+ :param ListAppRequest body: (required)
531+ :return: ListAppResponse
532+ If the method is called asynchronously,
533+ returns the request thread.
534+ """
535+ kwargs ['_return_http_data_only' ] = True
536+ if kwargs .get ('async_req' ):
537+ return self .list_app_with_http_info (body , ** kwargs ) # noqa: E501
538+ else :
539+ (data ) = self .list_app_with_http_info (body , ** kwargs ) # noqa: E501
540+ return data
541+
542+ def list_app_with_http_info (self , body , ** kwargs ): # noqa: E501
543+ """list_app # noqa: E501
544+
545+ This method makes a synchronous HTTP request by default. To make an
546+ asynchronous HTTP request, please pass async_req=True
547+ >>> thread = api.list_app_with_http_info(body, async_req=True)
548+ >>> result = thread.get()
549+
550+ :param async_req bool
551+ :param ListAppRequest body: (required)
552+ :return: ListAppResponse
553+ If the method is called asynchronously,
554+ returns the request thread.
555+ """
556+
557+ all_params = ['body' ] # noqa: E501
558+ all_params .append ('async_req' )
559+ all_params .append ('_return_http_data_only' )
560+ all_params .append ('_preload_content' )
561+ all_params .append ('_request_timeout' )
562+
563+ params = locals ()
564+ for key , val in six .iteritems (params ['kwargs' ]):
565+ if key not in all_params :
566+ raise TypeError (
567+ "Got an unexpected keyword argument '%s'"
568+ " to method list_app" % key
569+ )
570+ params [key ] = val
571+ del params ['kwargs' ]
572+ # verify the required parameter 'body' is set
573+ if self .api_client .client_side_validation and ('body' not in params or
574+ params ['body' ] is None ): # noqa: E501
575+ raise ValueError ("Missing the required parameter `body` when calling `list_app`" ) # noqa: E501
576+
577+ collection_formats = {}
578+
579+ path_params = {}
580+
581+ query_params = []
582+
583+ header_params = {}
584+
585+ form_params = []
586+ local_var_files = {}
587+
588+ body_params = None
589+ if 'body' in params :
590+ body_params = params ['body' ]
591+ # HTTP header `Accept`
592+ header_params ['Accept' ] = self .api_client .select_header_accept (
593+ ['application/json' ]) # noqa: E501
594+
595+ # HTTP header `Content-Type`
596+ header_params ['Content-Type' ] = self .api_client .select_header_content_type ( # noqa: E501
597+ ['application/json' ]) # noqa: E501
598+
599+ # Authentication setting
600+ auth_settings = ['volcengineSign' ] # noqa: E501
601+
602+ return self .api_client .call_api (
603+ '/ListApp/2025-05-01/acep/post/application_json/' , 'POST' ,
604+ path_params ,
605+ query_params ,
606+ header_params ,
607+ body = body_params ,
608+ post_params = form_params ,
609+ files = local_var_files ,
610+ response_type = 'ListAppResponse' , # noqa: E501
611+ auth_settings = auth_settings ,
612+ async_req = params .get ('async_req' ),
613+ _return_http_data_only = params .get ('_return_http_data_only' ),
614+ _preload_content = params .get ('_preload_content' , True ),
615+ _request_timeout = params .get ('_request_timeout' ),
616+ collection_formats = collection_formats )
617+
521618 def list_custom_route (self , body , ** kwargs ): # noqa: E501
522619 """list_custom_route # noqa: E501
523620
@@ -906,6 +1003,200 @@ def restore_pod_with_http_info(self, body, **kwargs): # noqa: E501
9061003 _request_timeout = params .get ('_request_timeout' ),
9071004 collection_formats = collection_formats )
9081005
1006+ def start_screen_shot (self , body , ** kwargs ): # noqa: E501
1007+ """start_screen_shot # noqa: E501
1008+
1009+ This method makes a synchronous HTTP request by default. To make an
1010+ asynchronous HTTP request, please pass async_req=True
1011+ >>> thread = api.start_screen_shot(body, async_req=True)
1012+ >>> result = thread.get()
1013+
1014+ :param async_req bool
1015+ :param StartScreenShotRequest body: (required)
1016+ :return: StartScreenShotResponse
1017+ If the method is called asynchronously,
1018+ returns the request thread.
1019+ """
1020+ kwargs ['_return_http_data_only' ] = True
1021+ if kwargs .get ('async_req' ):
1022+ return self .start_screen_shot_with_http_info (body , ** kwargs ) # noqa: E501
1023+ else :
1024+ (data ) = self .start_screen_shot_with_http_info (body , ** kwargs ) # noqa: E501
1025+ return data
1026+
1027+ def start_screen_shot_with_http_info (self , body , ** kwargs ): # noqa: E501
1028+ """start_screen_shot # noqa: E501
1029+
1030+ This method makes a synchronous HTTP request by default. To make an
1031+ asynchronous HTTP request, please pass async_req=True
1032+ >>> thread = api.start_screen_shot_with_http_info(body, async_req=True)
1033+ >>> result = thread.get()
1034+
1035+ :param async_req bool
1036+ :param StartScreenShotRequest body: (required)
1037+ :return: StartScreenShotResponse
1038+ If the method is called asynchronously,
1039+ returns the request thread.
1040+ """
1041+
1042+ all_params = ['body' ] # noqa: E501
1043+ all_params .append ('async_req' )
1044+ all_params .append ('_return_http_data_only' )
1045+ all_params .append ('_preload_content' )
1046+ all_params .append ('_request_timeout' )
1047+
1048+ params = locals ()
1049+ for key , val in six .iteritems (params ['kwargs' ]):
1050+ if key not in all_params :
1051+ raise TypeError (
1052+ "Got an unexpected keyword argument '%s'"
1053+ " to method start_screen_shot" % key
1054+ )
1055+ params [key ] = val
1056+ del params ['kwargs' ]
1057+ # verify the required parameter 'body' is set
1058+ if self .api_client .client_side_validation and ('body' not in params or
1059+ params ['body' ] is None ): # noqa: E501
1060+ raise ValueError ("Missing the required parameter `body` when calling `start_screen_shot`" ) # noqa: E501
1061+
1062+ collection_formats = {}
1063+
1064+ path_params = {}
1065+
1066+ query_params = []
1067+
1068+ header_params = {}
1069+
1070+ form_params = []
1071+ local_var_files = {}
1072+
1073+ body_params = None
1074+ if 'body' in params :
1075+ body_params = params ['body' ]
1076+ # HTTP header `Accept`
1077+ header_params ['Accept' ] = self .api_client .select_header_accept (
1078+ ['application/json' ]) # noqa: E501
1079+
1080+ # HTTP header `Content-Type`
1081+ header_params ['Content-Type' ] = self .api_client .select_header_content_type ( # noqa: E501
1082+ ['application/json' ]) # noqa: E501
1083+
1084+ # Authentication setting
1085+ auth_settings = ['volcengineSign' ] # noqa: E501
1086+
1087+ return self .api_client .call_api (
1088+ '/StartScreenShot/2025-05-01/acep/post/application_json/' , 'POST' ,
1089+ path_params ,
1090+ query_params ,
1091+ header_params ,
1092+ body = body_params ,
1093+ post_params = form_params ,
1094+ files = local_var_files ,
1095+ response_type = 'StartScreenShotResponse' , # noqa: E501
1096+ auth_settings = auth_settings ,
1097+ async_req = params .get ('async_req' ),
1098+ _return_http_data_only = params .get ('_return_http_data_only' ),
1099+ _preload_content = params .get ('_preload_content' , True ),
1100+ _request_timeout = params .get ('_request_timeout' ),
1101+ collection_formats = collection_formats )
1102+
1103+ def stop_screen_shot (self , body , ** kwargs ): # noqa: E501
1104+ """stop_screen_shot # noqa: E501
1105+
1106+ This method makes a synchronous HTTP request by default. To make an
1107+ asynchronous HTTP request, please pass async_req=True
1108+ >>> thread = api.stop_screen_shot(body, async_req=True)
1109+ >>> result = thread.get()
1110+
1111+ :param async_req bool
1112+ :param StopScreenShotRequest body: (required)
1113+ :return: StopScreenShotResponse
1114+ If the method is called asynchronously,
1115+ returns the request thread.
1116+ """
1117+ kwargs ['_return_http_data_only' ] = True
1118+ if kwargs .get ('async_req' ):
1119+ return self .stop_screen_shot_with_http_info (body , ** kwargs ) # noqa: E501
1120+ else :
1121+ (data ) = self .stop_screen_shot_with_http_info (body , ** kwargs ) # noqa: E501
1122+ return data
1123+
1124+ def stop_screen_shot_with_http_info (self , body , ** kwargs ): # noqa: E501
1125+ """stop_screen_shot # noqa: E501
1126+
1127+ This method makes a synchronous HTTP request by default. To make an
1128+ asynchronous HTTP request, please pass async_req=True
1129+ >>> thread = api.stop_screen_shot_with_http_info(body, async_req=True)
1130+ >>> result = thread.get()
1131+
1132+ :param async_req bool
1133+ :param StopScreenShotRequest body: (required)
1134+ :return: StopScreenShotResponse
1135+ If the method is called asynchronously,
1136+ returns the request thread.
1137+ """
1138+
1139+ all_params = ['body' ] # noqa: E501
1140+ all_params .append ('async_req' )
1141+ all_params .append ('_return_http_data_only' )
1142+ all_params .append ('_preload_content' )
1143+ all_params .append ('_request_timeout' )
1144+
1145+ params = locals ()
1146+ for key , val in six .iteritems (params ['kwargs' ]):
1147+ if key not in all_params :
1148+ raise TypeError (
1149+ "Got an unexpected keyword argument '%s'"
1150+ " to method stop_screen_shot" % key
1151+ )
1152+ params [key ] = val
1153+ del params ['kwargs' ]
1154+ # verify the required parameter 'body' is set
1155+ if self .api_client .client_side_validation and ('body' not in params or
1156+ params ['body' ] is None ): # noqa: E501
1157+ raise ValueError ("Missing the required parameter `body` when calling `stop_screen_shot`" ) # noqa: E501
1158+
1159+ collection_formats = {}
1160+
1161+ path_params = {}
1162+
1163+ query_params = []
1164+
1165+ header_params = {}
1166+
1167+ form_params = []
1168+ local_var_files = {}
1169+
1170+ body_params = None
1171+ if 'body' in params :
1172+ body_params = params ['body' ]
1173+ # HTTP header `Accept`
1174+ header_params ['Accept' ] = self .api_client .select_header_accept (
1175+ ['application/json' ]) # noqa: E501
1176+
1177+ # HTTP header `Content-Type`
1178+ header_params ['Content-Type' ] = self .api_client .select_header_content_type ( # noqa: E501
1179+ ['application/json' ]) # noqa: E501
1180+
1181+ # Authentication setting
1182+ auth_settings = ['volcengineSign' ] # noqa: E501
1183+
1184+ return self .api_client .call_api (
1185+ '/StopScreenShot/2025-05-01/acep/post/application_json/' , 'POST' ,
1186+ path_params ,
1187+ query_params ,
1188+ header_params ,
1189+ body = body_params ,
1190+ post_params = form_params ,
1191+ files = local_var_files ,
1192+ response_type = 'StopScreenShotResponse' , # noqa: E501
1193+ auth_settings = auth_settings ,
1194+ async_req = params .get ('async_req' ),
1195+ _return_http_data_only = params .get ('_return_http_data_only' ),
1196+ _preload_content = params .get ('_preload_content' , True ),
1197+ _request_timeout = params .get ('_request_timeout' ),
1198+ collection_formats = collection_formats )
1199+
9091200 def update_custom_route (self , body , ** kwargs ): # noqa: E501
9101201 """update_custom_route # noqa: E501
9111202
0 commit comments