volcengine-python-sdk 5.0.38__py2.py3-none-any.whl → 5.0.40__py2.py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (112) hide show
  1. {volcengine_python_sdk-5.0.38.dist-info → volcengine_python_sdk-5.0.40.dist-info}/METADATA +1 -1
  2. {volcengine_python_sdk-5.0.38.dist-info → volcengine_python_sdk-5.0.40.dist-info}/RECORD +112 -41
  3. volcenginesdkacep/__init__.py +16 -0
  4. volcenginesdkacep/api/acep_api.py +741 -62
  5. volcenginesdkacep/models/__init__.py +16 -0
  6. volcenginesdkacep/models/add_adb_key_request.py +257 -0
  7. volcenginesdkacep/models/add_adb_key_response.py +123 -0
  8. volcenginesdkacep/models/bind_adb_key_pods_request.py +177 -0
  9. volcenginesdkacep/models/bind_adb_key_pods_response.py +123 -0
  10. volcenginesdkacep/models/delete_adb_key_request.py +150 -0
  11. volcenginesdkacep/models/delete_adb_key_response.py +95 -0
  12. volcenginesdkacep/models/list_adb_key_pod_bindings_request.py +228 -0
  13. volcenginesdkacep/models/list_adb_key_pod_bindings_response.py +149 -0
  14. volcenginesdkacep/models/list_adb_key_request.py +306 -0
  15. volcenginesdkacep/models/list_adb_key_response.py +149 -0
  16. volcenginesdkacep/models/row_for_list_adb_key_output.py +331 -0
  17. volcenginesdkacep/models/row_for_list_adb_key_pod_bindings_output.py +305 -0
  18. volcenginesdkacep/models/unbind_adb_key_pods_request.py +177 -0
  19. volcenginesdkacep/models/unbind_adb_key_pods_response.py +123 -0
  20. volcenginesdkacep/models/update_adb_key_request.py +203 -0
  21. volcenginesdkacep/models/update_adb_key_response.py +95 -0
  22. volcenginesdkcen/__init__.py +4 -0
  23. volcenginesdkcen/api/cen_api.py +97 -0
  24. volcenginesdkcen/models/__init__.py +4 -0
  25. volcenginesdkcen/models/describe95_traffic_request.py +178 -0
  26. volcenginesdkcen/models/describe95_traffic_response.py +123 -0
  27. volcenginesdkcen/models/traffic_data_for_describe95_traffic_output.py +201 -0
  28. volcenginesdkcen/models/traffic_detail_data_for_describe95_traffic_output.py +175 -0
  29. volcenginesdkclawsentry/__init__.py +1 -0
  30. volcenginesdkclawsentry/models/__init__.py +1 -0
  31. volcenginesdkclawsentry/models/base_for_create_claw_input.py +3 -0
  32. volcenginesdkclawsentry/models/create_claw_request.py +121 -3
  33. volcenginesdkclawsentry/models/create_claw_response.py +55 -3
  34. volcenginesdkclawsentry/models/personal_claw_for_create_claw_input.py +129 -0
  35. volcenginesdkcore/api_client.py +1 -1
  36. volcenginesdkcore/configuration.py +1 -1
  37. volcenginesdkcore/endpoint/providers/default_provider.py +12 -0
  38. volcenginesdkcore/endpoint/providers/standard_provider.py +1 -0
  39. volcenginesdkflink20250101/__init__.py +40 -0
  40. volcenginesdkflink20250101/api/flink20250101_api.py +1194 -30
  41. volcenginesdkflink20250101/models/__init__.py +40 -0
  42. volcenginesdkflink20250101/models/available_savepoint_for_get_gws_start_method_output.py +331 -0
  43. volcenginesdkflink20250101/models/create_gmcs_resource_pool_request.py +441 -0
  44. volcenginesdkflink20250101/models/create_gmcs_resource_pool_response.py +253 -0
  45. volcenginesdkflink20250101/models/create_gws_application_draft_request.py +232 -0
  46. volcenginesdkflink20250101/models/create_gws_application_draft_response.py +539 -0
  47. volcenginesdkflink20250101/models/create_gws_savepoint_request.py +151 -0
  48. volcenginesdkflink20250101/models/create_gws_savepoint_response.py +175 -0
  49. volcenginesdkflink20250101/models/data_list_for_list_gmcs_resources_output.py +461 -0
  50. volcenginesdkflink20250101/models/delete_gmcs_resource_request.py +124 -0
  51. volcenginesdkflink20250101/models/delete_gmcs_resource_response.py +123 -0
  52. volcenginesdkflink20250101/models/dependency_for_list_gws_application_output.py +149 -0
  53. volcenginesdkflink20250101/models/deploy_gws_application_draft_request.py +284 -0
  54. volcenginesdkflink20250101/models/deploy_gws_application_draft_response.py +149 -0
  55. volcenginesdkflink20250101/models/deploy_request_for_list_gws_application_output.py +253 -0
  56. volcenginesdkflink20250101/models/extra_info_for_get_gmcs_resource_pool_output.py +175 -0
  57. volcenginesdkflink20250101/models/extra_info_for_list_gmcs_resources_output.py +175 -0
  58. volcenginesdkflink20250101/models/get_application_instance_response.py +289 -3
  59. volcenginesdkflink20250101/models/get_gmcs_resource_pool_request.py +124 -0
  60. volcenginesdkflink20250101/models/get_gmcs_resource_pool_response.py +539 -0
  61. volcenginesdkflink20250101/models/get_gws_start_method_request.py +124 -0
  62. volcenginesdkflink20250101/models/get_gws_start_method_response.py +175 -0
  63. volcenginesdkflink20250101/models/list_gmcs_resources_request.py +254 -0
  64. volcenginesdkflink20250101/models/list_gmcs_resources_response.py +201 -0
  65. volcenginesdkflink20250101/models/list_gws_application_request.py +322 -0
  66. volcenginesdkflink20250101/models/list_gws_application_response.py +201 -0
  67. volcenginesdkflink20250101/models/list_gws_savepoint_request.py +124 -0
  68. volcenginesdkflink20250101/models/list_gws_savepoint_response.py +123 -0
  69. volcenginesdkflink20250101/models/record_for_list_gws_application_output.py +747 -0
  70. volcenginesdkflink20250101/models/resource_for_create_gmcs_resource_pool_input.py +201 -0
  71. volcenginesdkflink20250101/models/resource_for_get_gmcs_resource_pool_output.py +201 -0
  72. volcenginesdkflink20250101/models/resource_for_list_gmcs_resources_output.py +201 -0
  73. volcenginesdkflink20250101/models/resource_for_update_gmcs_resource_pool_input.py +201 -0
  74. volcenginesdkflink20250101/models/savepoint_info_for_list_gws_savepoint_output.py +331 -0
  75. volcenginesdkflink20250101/models/tag_for_create_gmcs_resource_pool_input.py +149 -0
  76. volcenginesdkflink20250101/models/tag_for_create_gmcs_resource_pool_output.py +149 -0
  77. volcenginesdkflink20250101/models/tag_for_get_gmcs_resource_pool_output.py +149 -0
  78. volcenginesdkflink20250101/models/tag_for_list_gmcs_resources_output.py +149 -0
  79. volcenginesdkflink20250101/models/update_gmcs_resource_pool_request.py +254 -0
  80. volcenginesdkflink20250101/models/update_gmcs_resource_pool_response.py +149 -0
  81. volcenginesdkflink20250101/models/update_gws_application_draft_request.py +571 -0
  82. volcenginesdkflink20250101/models/update_gws_application_draft_response.py +149 -0
  83. volcenginesdkna/__init__.py +4 -0
  84. volcenginesdkna/api/na_api.py +97 -0
  85. volcenginesdkna/models/__init__.py +4 -0
  86. volcenginesdkna/models/create_path_analysis_request.py +27 -1
  87. volcenginesdkna/models/describe_instance_topology_request.py +157 -0
  88. volcenginesdkna/models/describe_instance_topology_response.py +149 -0
  89. volcenginesdkna/models/error_for_describe_instance_topology_output.py +149 -0
  90. volcenginesdkna/models/instance_topology_info_for_describe_instance_topology_output.py +305 -0
  91. volcenginesdktransitrouter/__init__.py +5 -1
  92. volcenginesdktransitrouter/api/transitrouter_api.py +97 -0
  93. volcenginesdktransitrouter/models/__init__.py +5 -1
  94. volcenginesdktransitrouter/models/describe95_traffic_request.py +185 -0
  95. volcenginesdktransitrouter/models/describe95_traffic_response.py +123 -0
  96. volcenginesdktransitrouter/models/describe_transit_router_multicast_domains_response.py +3 -3
  97. volcenginesdktransitrouter/models/describe_transit_router_vpn_attachments_request.py +3 -0
  98. volcenginesdktransitrouter/models/models.py +2172 -2172
  99. volcenginesdktransitrouter/models/traffic_data_for_describe95_traffic_output.py +201 -0
  100. volcenginesdktransitrouter/models/traffic_detail_data_for_describe95_traffic_output.py +175 -0
  101. volcenginesdktransitrouter/models/transit_router_attachment_for_describe_transit_router_vpn_attachments_output.py +27 -1
  102. volcenginesdktransitrouter/models/{transit_router_multicast_domains_for_describe_transit_router_multicast_domains_output.py → transit_router_multicast_domain_for_describe_transit_router_multicast_domains_output.py} +33 -33
  103. volcenginesdkvke/__init__.py +2 -0
  104. volcenginesdkvke/api/vke_api.py +97 -0
  105. volcenginesdkvke/models/__init__.py +2 -0
  106. volcenginesdkvke/models/item_for_list_scaling_policies_output.py +27 -1
  107. volcenginesdkvke/models/scale_node_pool_request.py +204 -0
  108. volcenginesdkvke/models/scale_node_pool_response.py +95 -0
  109. {volcengine_python_sdk-5.0.38.dist-info → volcengine_python_sdk-5.0.40.dist-info}/WHEEL +0 -0
  110. {volcengine_python_sdk-5.0.38.dist-info → volcengine_python_sdk-5.0.40.dist-info}/licenses/LICENSE.txt +0 -0
  111. {volcengine_python_sdk-5.0.38.dist-info → volcengine_python_sdk-5.0.40.dist-info}/licenses/NOTICE.md +0 -0
  112. {volcengine_python_sdk-5.0.38.dist-info → volcengine_python_sdk-5.0.40.dist-info}/top_level.txt +0 -0
@@ -33,6 +33,103 @@ class ACEPApi(object):
33
33
  api_client = volcenginesdkcore.ApiClient()
34
34
  self.api_client = api_client
35
35
 
36
+ def add_adb_key(self, body, **kwargs): # noqa: E501
37
+ """add_adb_key # noqa: E501
38
+
39
+ This method makes a synchronous HTTP request by default. To make an
40
+ asynchronous HTTP request, please pass async_req=True
41
+ >>> thread = api.add_adb_key(body, async_req=True)
42
+ >>> result = thread.get()
43
+
44
+ :param async_req bool
45
+ :param AddAdbKeyRequest body: (required)
46
+ :return: AddAdbKeyResponse
47
+ If the method is called asynchronously,
48
+ returns the request thread.
49
+ """
50
+ kwargs['_return_http_data_only'] = True
51
+ if kwargs.get('async_req'):
52
+ return self.add_adb_key_with_http_info(body, **kwargs) # noqa: E501
53
+ else:
54
+ (data) = self.add_adb_key_with_http_info(body, **kwargs) # noqa: E501
55
+ return data
56
+
57
+ def add_adb_key_with_http_info(self, body, **kwargs): # noqa: E501
58
+ """add_adb_key # noqa: E501
59
+
60
+ This method makes a synchronous HTTP request by default. To make an
61
+ asynchronous HTTP request, please pass async_req=True
62
+ >>> thread = api.add_adb_key_with_http_info(body, async_req=True)
63
+ >>> result = thread.get()
64
+
65
+ :param async_req bool
66
+ :param AddAdbKeyRequest body: (required)
67
+ :return: AddAdbKeyResponse
68
+ If the method is called asynchronously,
69
+ returns the request thread.
70
+ """
71
+
72
+ all_params = ['body'] # noqa: E501
73
+ all_params.append('async_req')
74
+ all_params.append('_return_http_data_only')
75
+ all_params.append('_preload_content')
76
+ all_params.append('_request_timeout')
77
+
78
+ params = locals()
79
+ for key, val in six.iteritems(params['kwargs']):
80
+ if key not in all_params:
81
+ raise TypeError(
82
+ "Got an unexpected keyword argument '%s'"
83
+ " to method add_adb_key" % key
84
+ )
85
+ params[key] = val
86
+ del params['kwargs']
87
+ # verify the required parameter 'body' is set
88
+ if self.api_client.client_side_validation and ('body' not in params or
89
+ params['body'] is None): # noqa: E501
90
+ raise ValueError("Missing the required parameter `body` when calling `add_adb_key`") # noqa: E501
91
+
92
+ collection_formats = {}
93
+
94
+ path_params = {}
95
+
96
+ query_params = []
97
+
98
+ header_params = {}
99
+
100
+ form_params = []
101
+ local_var_files = {}
102
+
103
+ body_params = None
104
+ if 'body' in params:
105
+ body_params = params['body']
106
+ # HTTP header `Accept`
107
+ header_params['Accept'] = self.api_client.select_header_accept(
108
+ ['application/json']) # noqa: E501
109
+
110
+ # HTTP header `Content-Type`
111
+ header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
112
+ ['application/json']) # noqa: E501
113
+
114
+ # Authentication setting
115
+ auth_settings = ['volcengineSign'] # noqa: E501
116
+
117
+ return self.api_client.call_api(
118
+ '/AddAdbKey/2025-05-01/acep/post/application_json/', 'POST',
119
+ path_params,
120
+ query_params,
121
+ header_params,
122
+ body=body_params,
123
+ post_params=form_params,
124
+ files=local_var_files,
125
+ response_type='AddAdbKeyResponse', # noqa: E501
126
+ auth_settings=auth_settings,
127
+ async_req=params.get('async_req'),
128
+ _return_http_data_only=params.get('_return_http_data_only'),
129
+ _preload_content=params.get('_preload_content', True),
130
+ _request_timeout=params.get('_request_timeout'),
131
+ collection_formats=collection_formats)
132
+
36
133
  def add_custom_route(self, body, **kwargs): # noqa: E501
37
134
  """add_custom_route # noqa: E501
38
135
 
@@ -809,6 +906,103 @@ class ACEPApi(object):
809
906
  _request_timeout=params.get('_request_timeout'),
810
907
  collection_formats=collection_formats)
811
908
 
909
+ def bind_adb_key_pods(self, body, **kwargs): # noqa: E501
910
+ """bind_adb_key_pods # noqa: E501
911
+
912
+ This method makes a synchronous HTTP request by default. To make an
913
+ asynchronous HTTP request, please pass async_req=True
914
+ >>> thread = api.bind_adb_key_pods(body, async_req=True)
915
+ >>> result = thread.get()
916
+
917
+ :param async_req bool
918
+ :param BindAdbKeyPodsRequest body: (required)
919
+ :return: BindAdbKeyPodsResponse
920
+ If the method is called asynchronously,
921
+ returns the request thread.
922
+ """
923
+ kwargs['_return_http_data_only'] = True
924
+ if kwargs.get('async_req'):
925
+ return self.bind_adb_key_pods_with_http_info(body, **kwargs) # noqa: E501
926
+ else:
927
+ (data) = self.bind_adb_key_pods_with_http_info(body, **kwargs) # noqa: E501
928
+ return data
929
+
930
+ def bind_adb_key_pods_with_http_info(self, body, **kwargs): # noqa: E501
931
+ """bind_adb_key_pods # noqa: E501
932
+
933
+ This method makes a synchronous HTTP request by default. To make an
934
+ asynchronous HTTP request, please pass async_req=True
935
+ >>> thread = api.bind_adb_key_pods_with_http_info(body, async_req=True)
936
+ >>> result = thread.get()
937
+
938
+ :param async_req bool
939
+ :param BindAdbKeyPodsRequest body: (required)
940
+ :return: BindAdbKeyPodsResponse
941
+ If the method is called asynchronously,
942
+ returns the request thread.
943
+ """
944
+
945
+ all_params = ['body'] # noqa: E501
946
+ all_params.append('async_req')
947
+ all_params.append('_return_http_data_only')
948
+ all_params.append('_preload_content')
949
+ all_params.append('_request_timeout')
950
+
951
+ params = locals()
952
+ for key, val in six.iteritems(params['kwargs']):
953
+ if key not in all_params:
954
+ raise TypeError(
955
+ "Got an unexpected keyword argument '%s'"
956
+ " to method bind_adb_key_pods" % key
957
+ )
958
+ params[key] = val
959
+ del params['kwargs']
960
+ # verify the required parameter 'body' is set
961
+ if self.api_client.client_side_validation and ('body' not in params or
962
+ params['body'] is None): # noqa: E501
963
+ raise ValueError("Missing the required parameter `body` when calling `bind_adb_key_pods`") # noqa: E501
964
+
965
+ collection_formats = {}
966
+
967
+ path_params = {}
968
+
969
+ query_params = []
970
+
971
+ header_params = {}
972
+
973
+ form_params = []
974
+ local_var_files = {}
975
+
976
+ body_params = None
977
+ if 'body' in params:
978
+ body_params = params['body']
979
+ # HTTP header `Accept`
980
+ header_params['Accept'] = self.api_client.select_header_accept(
981
+ ['application/json']) # noqa: E501
982
+
983
+ # HTTP header `Content-Type`
984
+ header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
985
+ ['application/json']) # noqa: E501
986
+
987
+ # Authentication setting
988
+ auth_settings = ['volcengineSign'] # noqa: E501
989
+
990
+ return self.api_client.call_api(
991
+ '/BindAdbKeyPods/2025-05-01/acep/post/application_json/', 'POST',
992
+ path_params,
993
+ query_params,
994
+ header_params,
995
+ body=body_params,
996
+ post_params=form_params,
997
+ files=local_var_files,
998
+ response_type='BindAdbKeyPodsResponse', # noqa: E501
999
+ auth_settings=auth_settings,
1000
+ async_req=params.get('async_req'),
1001
+ _return_http_data_only=params.get('_return_http_data_only'),
1002
+ _preload_content=params.get('_preload_content', True),
1003
+ _request_timeout=params.get('_request_timeout'),
1004
+ collection_formats=collection_formats)
1005
+
812
1006
  def bind_port_mapping_rule(self, body, **kwargs): # noqa: E501
813
1007
  """bind_port_mapping_rule # noqa: E501
814
1008
 
@@ -1973,6 +2167,103 @@ class ACEPApi(object):
1973
2167
  _request_timeout=params.get('_request_timeout'),
1974
2168
  collection_formats=collection_formats)
1975
2169
 
2170
+ def delete_adb_key(self, body, **kwargs): # noqa: E501
2171
+ """delete_adb_key # noqa: E501
2172
+
2173
+ This method makes a synchronous HTTP request by default. To make an
2174
+ asynchronous HTTP request, please pass async_req=True
2175
+ >>> thread = api.delete_adb_key(body, async_req=True)
2176
+ >>> result = thread.get()
2177
+
2178
+ :param async_req bool
2179
+ :param DeleteAdbKeyRequest body: (required)
2180
+ :return: DeleteAdbKeyResponse
2181
+ If the method is called asynchronously,
2182
+ returns the request thread.
2183
+ """
2184
+ kwargs['_return_http_data_only'] = True
2185
+ if kwargs.get('async_req'):
2186
+ return self.delete_adb_key_with_http_info(body, **kwargs) # noqa: E501
2187
+ else:
2188
+ (data) = self.delete_adb_key_with_http_info(body, **kwargs) # noqa: E501
2189
+ return data
2190
+
2191
+ def delete_adb_key_with_http_info(self, body, **kwargs): # noqa: E501
2192
+ """delete_adb_key # noqa: E501
2193
+
2194
+ This method makes a synchronous HTTP request by default. To make an
2195
+ asynchronous HTTP request, please pass async_req=True
2196
+ >>> thread = api.delete_adb_key_with_http_info(body, async_req=True)
2197
+ >>> result = thread.get()
2198
+
2199
+ :param async_req bool
2200
+ :param DeleteAdbKeyRequest body: (required)
2201
+ :return: DeleteAdbKeyResponse
2202
+ If the method is called asynchronously,
2203
+ returns the request thread.
2204
+ """
2205
+
2206
+ all_params = ['body'] # noqa: E501
2207
+ all_params.append('async_req')
2208
+ all_params.append('_return_http_data_only')
2209
+ all_params.append('_preload_content')
2210
+ all_params.append('_request_timeout')
2211
+
2212
+ params = locals()
2213
+ for key, val in six.iteritems(params['kwargs']):
2214
+ if key not in all_params:
2215
+ raise TypeError(
2216
+ "Got an unexpected keyword argument '%s'"
2217
+ " to method delete_adb_key" % key
2218
+ )
2219
+ params[key] = val
2220
+ del params['kwargs']
2221
+ # verify the required parameter 'body' is set
2222
+ if self.api_client.client_side_validation and ('body' not in params or
2223
+ params['body'] is None): # noqa: E501
2224
+ raise ValueError("Missing the required parameter `body` when calling `delete_adb_key`") # noqa: E501
2225
+
2226
+ collection_formats = {}
2227
+
2228
+ path_params = {}
2229
+
2230
+ query_params = []
2231
+
2232
+ header_params = {}
2233
+
2234
+ form_params = []
2235
+ local_var_files = {}
2236
+
2237
+ body_params = None
2238
+ if 'body' in params:
2239
+ body_params = params['body']
2240
+ # HTTP header `Accept`
2241
+ header_params['Accept'] = self.api_client.select_header_accept(
2242
+ ['application/json']) # noqa: E501
2243
+
2244
+ # HTTP header `Content-Type`
2245
+ header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
2246
+ ['application/json']) # noqa: E501
2247
+
2248
+ # Authentication setting
2249
+ auth_settings = ['volcengineSign'] # noqa: E501
2250
+
2251
+ return self.api_client.call_api(
2252
+ '/DeleteAdbKey/2025-05-01/acep/post/application_json/', 'POST',
2253
+ path_params,
2254
+ query_params,
2255
+ header_params,
2256
+ body=body_params,
2257
+ post_params=form_params,
2258
+ files=local_var_files,
2259
+ response_type='DeleteAdbKeyResponse', # noqa: E501
2260
+ auth_settings=auth_settings,
2261
+ async_req=params.get('async_req'),
2262
+ _return_http_data_only=params.get('_return_http_data_only'),
2263
+ _preload_content=params.get('_preload_content', True),
2264
+ _request_timeout=params.get('_request_timeout'),
2265
+ collection_formats=collection_formats)
2266
+
1976
2267
  def delete_aosp_image(self, body, **kwargs): # noqa: E501
1977
2268
  """delete_aosp_image # noqa: E501
1978
2269
 
@@ -4403,33 +4694,227 @@ class ACEPApi(object):
4403
4694
 
4404
4695
  This method makes a synchronous HTTP request by default. To make an
4405
4696
  asynchronous HTTP request, please pass async_req=True
4406
- >>> thread = api.install_app(body, async_req=True)
4697
+ >>> thread = api.install_app(body, async_req=True)
4698
+ >>> result = thread.get()
4699
+
4700
+ :param async_req bool
4701
+ :param InstallAppRequest body: (required)
4702
+ :return: InstallAppResponse
4703
+ If the method is called asynchronously,
4704
+ returns the request thread.
4705
+ """
4706
+ kwargs['_return_http_data_only'] = True
4707
+ if kwargs.get('async_req'):
4708
+ return self.install_app_with_http_info(body, **kwargs) # noqa: E501
4709
+ else:
4710
+ (data) = self.install_app_with_http_info(body, **kwargs) # noqa: E501
4711
+ return data
4712
+
4713
+ def install_app_with_http_info(self, body, **kwargs): # noqa: E501
4714
+ """install_app # noqa: E501
4715
+
4716
+ This method makes a synchronous HTTP request by default. To make an
4717
+ asynchronous HTTP request, please pass async_req=True
4718
+ >>> thread = api.install_app_with_http_info(body, async_req=True)
4719
+ >>> result = thread.get()
4720
+
4721
+ :param async_req bool
4722
+ :param InstallAppRequest body: (required)
4723
+ :return: InstallAppResponse
4724
+ If the method is called asynchronously,
4725
+ returns the request thread.
4726
+ """
4727
+
4728
+ all_params = ['body'] # noqa: E501
4729
+ all_params.append('async_req')
4730
+ all_params.append('_return_http_data_only')
4731
+ all_params.append('_preload_content')
4732
+ all_params.append('_request_timeout')
4733
+
4734
+ params = locals()
4735
+ for key, val in six.iteritems(params['kwargs']):
4736
+ if key not in all_params:
4737
+ raise TypeError(
4738
+ "Got an unexpected keyword argument '%s'"
4739
+ " to method install_app" % key
4740
+ )
4741
+ params[key] = val
4742
+ del params['kwargs']
4743
+ # verify the required parameter 'body' is set
4744
+ if self.api_client.client_side_validation and ('body' not in params or
4745
+ params['body'] is None): # noqa: E501
4746
+ raise ValueError("Missing the required parameter `body` when calling `install_app`") # noqa: E501
4747
+
4748
+ collection_formats = {}
4749
+
4750
+ path_params = {}
4751
+
4752
+ query_params = []
4753
+
4754
+ header_params = {}
4755
+
4756
+ form_params = []
4757
+ local_var_files = {}
4758
+
4759
+ body_params = None
4760
+ if 'body' in params:
4761
+ body_params = params['body']
4762
+ # HTTP header `Accept`
4763
+ header_params['Accept'] = self.api_client.select_header_accept(
4764
+ ['application/json']) # noqa: E501
4765
+
4766
+ # HTTP header `Content-Type`
4767
+ header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
4768
+ ['application/json']) # noqa: E501
4769
+
4770
+ # Authentication setting
4771
+ auth_settings = ['volcengineSign'] # noqa: E501
4772
+
4773
+ return self.api_client.call_api(
4774
+ '/InstallApp/2025-05-01/acep/post/application_json/', 'POST',
4775
+ path_params,
4776
+ query_params,
4777
+ header_params,
4778
+ body=body_params,
4779
+ post_params=form_params,
4780
+ files=local_var_files,
4781
+ response_type='InstallAppResponse', # noqa: E501
4782
+ auth_settings=auth_settings,
4783
+ async_req=params.get('async_req'),
4784
+ _return_http_data_only=params.get('_return_http_data_only'),
4785
+ _preload_content=params.get('_preload_content', True),
4786
+ _request_timeout=params.get('_request_timeout'),
4787
+ collection_formats=collection_formats)
4788
+
4789
+ def install_apps(self, body, **kwargs): # noqa: E501
4790
+ """install_apps # noqa: E501
4791
+
4792
+ This method makes a synchronous HTTP request by default. To make an
4793
+ asynchronous HTTP request, please pass async_req=True
4794
+ >>> thread = api.install_apps(body, async_req=True)
4795
+ >>> result = thread.get()
4796
+
4797
+ :param async_req bool
4798
+ :param InstallAppsRequest body: (required)
4799
+ :return: InstallAppsResponse
4800
+ If the method is called asynchronously,
4801
+ returns the request thread.
4802
+ """
4803
+ kwargs['_return_http_data_only'] = True
4804
+ if kwargs.get('async_req'):
4805
+ return self.install_apps_with_http_info(body, **kwargs) # noqa: E501
4806
+ else:
4807
+ (data) = self.install_apps_with_http_info(body, **kwargs) # noqa: E501
4808
+ return data
4809
+
4810
+ def install_apps_with_http_info(self, body, **kwargs): # noqa: E501
4811
+ """install_apps # noqa: E501
4812
+
4813
+ This method makes a synchronous HTTP request by default. To make an
4814
+ asynchronous HTTP request, please pass async_req=True
4815
+ >>> thread = api.install_apps_with_http_info(body, async_req=True)
4816
+ >>> result = thread.get()
4817
+
4818
+ :param async_req bool
4819
+ :param InstallAppsRequest body: (required)
4820
+ :return: InstallAppsResponse
4821
+ If the method is called asynchronously,
4822
+ returns the request thread.
4823
+ """
4824
+
4825
+ all_params = ['body'] # noqa: E501
4826
+ all_params.append('async_req')
4827
+ all_params.append('_return_http_data_only')
4828
+ all_params.append('_preload_content')
4829
+ all_params.append('_request_timeout')
4830
+
4831
+ params = locals()
4832
+ for key, val in six.iteritems(params['kwargs']):
4833
+ if key not in all_params:
4834
+ raise TypeError(
4835
+ "Got an unexpected keyword argument '%s'"
4836
+ " to method install_apps" % key
4837
+ )
4838
+ params[key] = val
4839
+ del params['kwargs']
4840
+ # verify the required parameter 'body' is set
4841
+ if self.api_client.client_side_validation and ('body' not in params or
4842
+ params['body'] is None): # noqa: E501
4843
+ raise ValueError("Missing the required parameter `body` when calling `install_apps`") # noqa: E501
4844
+
4845
+ collection_formats = {}
4846
+
4847
+ path_params = {}
4848
+
4849
+ query_params = []
4850
+
4851
+ header_params = {}
4852
+
4853
+ form_params = []
4854
+ local_var_files = {}
4855
+
4856
+ body_params = None
4857
+ if 'body' in params:
4858
+ body_params = params['body']
4859
+ # HTTP header `Accept`
4860
+ header_params['Accept'] = self.api_client.select_header_accept(
4861
+ ['application/json']) # noqa: E501
4862
+
4863
+ # HTTP header `Content-Type`
4864
+ header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
4865
+ ['application/json']) # noqa: E501
4866
+
4867
+ # Authentication setting
4868
+ auth_settings = ['volcengineSign'] # noqa: E501
4869
+
4870
+ return self.api_client.call_api(
4871
+ '/InstallApps/2025-05-01/acep/post/application_json/', 'POST',
4872
+ path_params,
4873
+ query_params,
4874
+ header_params,
4875
+ body=body_params,
4876
+ post_params=form_params,
4877
+ files=local_var_files,
4878
+ response_type='InstallAppsResponse', # noqa: E501
4879
+ auth_settings=auth_settings,
4880
+ async_req=params.get('async_req'),
4881
+ _return_http_data_only=params.get('_return_http_data_only'),
4882
+ _preload_content=params.get('_preload_content', True),
4883
+ _request_timeout=params.get('_request_timeout'),
4884
+ collection_formats=collection_formats)
4885
+
4886
+ def launch_app(self, body, **kwargs): # noqa: E501
4887
+ """launch_app # noqa: E501
4888
+
4889
+ This method makes a synchronous HTTP request by default. To make an
4890
+ asynchronous HTTP request, please pass async_req=True
4891
+ >>> thread = api.launch_app(body, async_req=True)
4407
4892
  >>> result = thread.get()
4408
4893
 
4409
4894
  :param async_req bool
4410
- :param InstallAppRequest body: (required)
4411
- :return: InstallAppResponse
4895
+ :param LaunchAppRequest body: (required)
4896
+ :return: LaunchAppResponse
4412
4897
  If the method is called asynchronously,
4413
4898
  returns the request thread.
4414
4899
  """
4415
4900
  kwargs['_return_http_data_only'] = True
4416
4901
  if kwargs.get('async_req'):
4417
- return self.install_app_with_http_info(body, **kwargs) # noqa: E501
4902
+ return self.launch_app_with_http_info(body, **kwargs) # noqa: E501
4418
4903
  else:
4419
- (data) = self.install_app_with_http_info(body, **kwargs) # noqa: E501
4904
+ (data) = self.launch_app_with_http_info(body, **kwargs) # noqa: E501
4420
4905
  return data
4421
4906
 
4422
- def install_app_with_http_info(self, body, **kwargs): # noqa: E501
4423
- """install_app # noqa: E501
4907
+ def launch_app_with_http_info(self, body, **kwargs): # noqa: E501
4908
+ """launch_app # noqa: E501
4424
4909
 
4425
4910
  This method makes a synchronous HTTP request by default. To make an
4426
4911
  asynchronous HTTP request, please pass async_req=True
4427
- >>> thread = api.install_app_with_http_info(body, async_req=True)
4912
+ >>> thread = api.launch_app_with_http_info(body, async_req=True)
4428
4913
  >>> result = thread.get()
4429
4914
 
4430
4915
  :param async_req bool
4431
- :param InstallAppRequest body: (required)
4432
- :return: InstallAppResponse
4916
+ :param LaunchAppRequest body: (required)
4917
+ :return: LaunchAppResponse
4433
4918
  If the method is called asynchronously,
4434
4919
  returns the request thread.
4435
4920
  """
@@ -4445,14 +4930,14 @@ class ACEPApi(object):
4445
4930
  if key not in all_params:
4446
4931
  raise TypeError(
4447
4932
  "Got an unexpected keyword argument '%s'"
4448
- " to method install_app" % key
4933
+ " to method launch_app" % key
4449
4934
  )
4450
4935
  params[key] = val
4451
4936
  del params['kwargs']
4452
4937
  # verify the required parameter 'body' is set
4453
4938
  if self.api_client.client_side_validation and ('body' not in params or
4454
4939
  params['body'] is None): # noqa: E501
4455
- raise ValueError("Missing the required parameter `body` when calling `install_app`") # noqa: E501
4940
+ raise ValueError("Missing the required parameter `body` when calling `launch_app`") # noqa: E501
4456
4941
 
4457
4942
  collection_formats = {}
4458
4943
 
@@ -4480,14 +4965,14 @@ class ACEPApi(object):
4480
4965
  auth_settings = ['volcengineSign'] # noqa: E501
4481
4966
 
4482
4967
  return self.api_client.call_api(
4483
- '/InstallApp/2025-05-01/acep/post/application_json/', 'POST',
4968
+ '/LaunchApp/2025-05-01/acep/post/application_json/', 'POST',
4484
4969
  path_params,
4485
4970
  query_params,
4486
4971
  header_params,
4487
4972
  body=body_params,
4488
4973
  post_params=form_params,
4489
4974
  files=local_var_files,
4490
- response_type='InstallAppResponse', # noqa: E501
4975
+ response_type='LaunchAppResponse', # noqa: E501
4491
4976
  auth_settings=auth_settings,
4492
4977
  async_req=params.get('async_req'),
4493
4978
  _return_http_data_only=params.get('_return_http_data_only'),
@@ -4495,38 +4980,38 @@ class ACEPApi(object):
4495
4980
  _request_timeout=params.get('_request_timeout'),
4496
4981
  collection_formats=collection_formats)
4497
4982
 
4498
- def install_apps(self, body, **kwargs): # noqa: E501
4499
- """install_apps # noqa: E501
4983
+ def launch_apps(self, body, **kwargs): # noqa: E501
4984
+ """launch_apps # noqa: E501
4500
4985
 
4501
4986
  This method makes a synchronous HTTP request by default. To make an
4502
4987
  asynchronous HTTP request, please pass async_req=True
4503
- >>> thread = api.install_apps(body, async_req=True)
4988
+ >>> thread = api.launch_apps(body, async_req=True)
4504
4989
  >>> result = thread.get()
4505
4990
 
4506
4991
  :param async_req bool
4507
- :param InstallAppsRequest body: (required)
4508
- :return: InstallAppsResponse
4992
+ :param LaunchAppsRequest body: (required)
4993
+ :return: LaunchAppsResponse
4509
4994
  If the method is called asynchronously,
4510
4995
  returns the request thread.
4511
4996
  """
4512
4997
  kwargs['_return_http_data_only'] = True
4513
4998
  if kwargs.get('async_req'):
4514
- return self.install_apps_with_http_info(body, **kwargs) # noqa: E501
4999
+ return self.launch_apps_with_http_info(body, **kwargs) # noqa: E501
4515
5000
  else:
4516
- (data) = self.install_apps_with_http_info(body, **kwargs) # noqa: E501
5001
+ (data) = self.launch_apps_with_http_info(body, **kwargs) # noqa: E501
4517
5002
  return data
4518
5003
 
4519
- def install_apps_with_http_info(self, body, **kwargs): # noqa: E501
4520
- """install_apps # noqa: E501
5004
+ def launch_apps_with_http_info(self, body, **kwargs): # noqa: E501
5005
+ """launch_apps # noqa: E501
4521
5006
 
4522
5007
  This method makes a synchronous HTTP request by default. To make an
4523
5008
  asynchronous HTTP request, please pass async_req=True
4524
- >>> thread = api.install_apps_with_http_info(body, async_req=True)
5009
+ >>> thread = api.launch_apps_with_http_info(body, async_req=True)
4525
5010
  >>> result = thread.get()
4526
5011
 
4527
5012
  :param async_req bool
4528
- :param InstallAppsRequest body: (required)
4529
- :return: InstallAppsResponse
5013
+ :param LaunchAppsRequest body: (required)
5014
+ :return: LaunchAppsResponse
4530
5015
  If the method is called asynchronously,
4531
5016
  returns the request thread.
4532
5017
  """
@@ -4542,14 +5027,14 @@ class ACEPApi(object):
4542
5027
  if key not in all_params:
4543
5028
  raise TypeError(
4544
5029
  "Got an unexpected keyword argument '%s'"
4545
- " to method install_apps" % key
5030
+ " to method launch_apps" % key
4546
5031
  )
4547
5032
  params[key] = val
4548
5033
  del params['kwargs']
4549
5034
  # verify the required parameter 'body' is set
4550
5035
  if self.api_client.client_side_validation and ('body' not in params or
4551
5036
  params['body'] is None): # noqa: E501
4552
- raise ValueError("Missing the required parameter `body` when calling `install_apps`") # noqa: E501
5037
+ raise ValueError("Missing the required parameter `body` when calling `launch_apps`") # noqa: E501
4553
5038
 
4554
5039
  collection_formats = {}
4555
5040
 
@@ -4577,14 +5062,14 @@ class ACEPApi(object):
4577
5062
  auth_settings = ['volcengineSign'] # noqa: E501
4578
5063
 
4579
5064
  return self.api_client.call_api(
4580
- '/InstallApps/2025-05-01/acep/post/application_json/', 'POST',
5065
+ '/LaunchApps/2025-05-01/acep/post/application_json/', 'POST',
4581
5066
  path_params,
4582
5067
  query_params,
4583
5068
  header_params,
4584
5069
  body=body_params,
4585
5070
  post_params=form_params,
4586
5071
  files=local_var_files,
4587
- response_type='InstallAppsResponse', # noqa: E501
5072
+ response_type='LaunchAppsResponse', # noqa: E501
4588
5073
  auth_settings=auth_settings,
4589
5074
  async_req=params.get('async_req'),
4590
5075
  _return_http_data_only=params.get('_return_http_data_only'),
@@ -4592,38 +5077,38 @@ class ACEPApi(object):
4592
5077
  _request_timeout=params.get('_request_timeout'),
4593
5078
  collection_formats=collection_formats)
4594
5079
 
4595
- def launch_app(self, body, **kwargs): # noqa: E501
4596
- """launch_app # noqa: E501
5080
+ def list_adb_key(self, body, **kwargs): # noqa: E501
5081
+ """list_adb_key # noqa: E501
4597
5082
 
4598
5083
  This method makes a synchronous HTTP request by default. To make an
4599
5084
  asynchronous HTTP request, please pass async_req=True
4600
- >>> thread = api.launch_app(body, async_req=True)
5085
+ >>> thread = api.list_adb_key(body, async_req=True)
4601
5086
  >>> result = thread.get()
4602
5087
 
4603
5088
  :param async_req bool
4604
- :param LaunchAppRequest body: (required)
4605
- :return: LaunchAppResponse
5089
+ :param ListAdbKeyRequest body: (required)
5090
+ :return: ListAdbKeyResponse
4606
5091
  If the method is called asynchronously,
4607
5092
  returns the request thread.
4608
5093
  """
4609
5094
  kwargs['_return_http_data_only'] = True
4610
5095
  if kwargs.get('async_req'):
4611
- return self.launch_app_with_http_info(body, **kwargs) # noqa: E501
5096
+ return self.list_adb_key_with_http_info(body, **kwargs) # noqa: E501
4612
5097
  else:
4613
- (data) = self.launch_app_with_http_info(body, **kwargs) # noqa: E501
5098
+ (data) = self.list_adb_key_with_http_info(body, **kwargs) # noqa: E501
4614
5099
  return data
4615
5100
 
4616
- def launch_app_with_http_info(self, body, **kwargs): # noqa: E501
4617
- """launch_app # noqa: E501
5101
+ def list_adb_key_with_http_info(self, body, **kwargs): # noqa: E501
5102
+ """list_adb_key # noqa: E501
4618
5103
 
4619
5104
  This method makes a synchronous HTTP request by default. To make an
4620
5105
  asynchronous HTTP request, please pass async_req=True
4621
- >>> thread = api.launch_app_with_http_info(body, async_req=True)
5106
+ >>> thread = api.list_adb_key_with_http_info(body, async_req=True)
4622
5107
  >>> result = thread.get()
4623
5108
 
4624
5109
  :param async_req bool
4625
- :param LaunchAppRequest body: (required)
4626
- :return: LaunchAppResponse
5110
+ :param ListAdbKeyRequest body: (required)
5111
+ :return: ListAdbKeyResponse
4627
5112
  If the method is called asynchronously,
4628
5113
  returns the request thread.
4629
5114
  """
@@ -4639,14 +5124,14 @@ class ACEPApi(object):
4639
5124
  if key not in all_params:
4640
5125
  raise TypeError(
4641
5126
  "Got an unexpected keyword argument '%s'"
4642
- " to method launch_app" % key
5127
+ " to method list_adb_key" % key
4643
5128
  )
4644
5129
  params[key] = val
4645
5130
  del params['kwargs']
4646
5131
  # verify the required parameter 'body' is set
4647
5132
  if self.api_client.client_side_validation and ('body' not in params or
4648
5133
  params['body'] is None): # noqa: E501
4649
- raise ValueError("Missing the required parameter `body` when calling `launch_app`") # noqa: E501
5134
+ raise ValueError("Missing the required parameter `body` when calling `list_adb_key`") # noqa: E501
4650
5135
 
4651
5136
  collection_formats = {}
4652
5137
 
@@ -4674,14 +5159,14 @@ class ACEPApi(object):
4674
5159
  auth_settings = ['volcengineSign'] # noqa: E501
4675
5160
 
4676
5161
  return self.api_client.call_api(
4677
- '/LaunchApp/2025-05-01/acep/post/application_json/', 'POST',
5162
+ '/ListAdbKey/2025-05-01/acep/post/application_json/', 'POST',
4678
5163
  path_params,
4679
5164
  query_params,
4680
5165
  header_params,
4681
5166
  body=body_params,
4682
5167
  post_params=form_params,
4683
5168
  files=local_var_files,
4684
- response_type='LaunchAppResponse', # noqa: E501
5169
+ response_type='ListAdbKeyResponse', # noqa: E501
4685
5170
  auth_settings=auth_settings,
4686
5171
  async_req=params.get('async_req'),
4687
5172
  _return_http_data_only=params.get('_return_http_data_only'),
@@ -4689,38 +5174,38 @@ class ACEPApi(object):
4689
5174
  _request_timeout=params.get('_request_timeout'),
4690
5175
  collection_formats=collection_formats)
4691
5176
 
4692
- def launch_apps(self, body, **kwargs): # noqa: E501
4693
- """launch_apps # noqa: E501
5177
+ def list_adb_key_pod_bindings(self, body, **kwargs): # noqa: E501
5178
+ """list_adb_key_pod_bindings # noqa: E501
4694
5179
 
4695
5180
  This method makes a synchronous HTTP request by default. To make an
4696
5181
  asynchronous HTTP request, please pass async_req=True
4697
- >>> thread = api.launch_apps(body, async_req=True)
5182
+ >>> thread = api.list_adb_key_pod_bindings(body, async_req=True)
4698
5183
  >>> result = thread.get()
4699
5184
 
4700
5185
  :param async_req bool
4701
- :param LaunchAppsRequest body: (required)
4702
- :return: LaunchAppsResponse
5186
+ :param ListAdbKeyPodBindingsRequest body: (required)
5187
+ :return: ListAdbKeyPodBindingsResponse
4703
5188
  If the method is called asynchronously,
4704
5189
  returns the request thread.
4705
5190
  """
4706
5191
  kwargs['_return_http_data_only'] = True
4707
5192
  if kwargs.get('async_req'):
4708
- return self.launch_apps_with_http_info(body, **kwargs) # noqa: E501
5193
+ return self.list_adb_key_pod_bindings_with_http_info(body, **kwargs) # noqa: E501
4709
5194
  else:
4710
- (data) = self.launch_apps_with_http_info(body, **kwargs) # noqa: E501
5195
+ (data) = self.list_adb_key_pod_bindings_with_http_info(body, **kwargs) # noqa: E501
4711
5196
  return data
4712
5197
 
4713
- def launch_apps_with_http_info(self, body, **kwargs): # noqa: E501
4714
- """launch_apps # noqa: E501
5198
+ def list_adb_key_pod_bindings_with_http_info(self, body, **kwargs): # noqa: E501
5199
+ """list_adb_key_pod_bindings # noqa: E501
4715
5200
 
4716
5201
  This method makes a synchronous HTTP request by default. To make an
4717
5202
  asynchronous HTTP request, please pass async_req=True
4718
- >>> thread = api.launch_apps_with_http_info(body, async_req=True)
5203
+ >>> thread = api.list_adb_key_pod_bindings_with_http_info(body, async_req=True)
4719
5204
  >>> result = thread.get()
4720
5205
 
4721
5206
  :param async_req bool
4722
- :param LaunchAppsRequest body: (required)
4723
- :return: LaunchAppsResponse
5207
+ :param ListAdbKeyPodBindingsRequest body: (required)
5208
+ :return: ListAdbKeyPodBindingsResponse
4724
5209
  If the method is called asynchronously,
4725
5210
  returns the request thread.
4726
5211
  """
@@ -4736,14 +5221,14 @@ class ACEPApi(object):
4736
5221
  if key not in all_params:
4737
5222
  raise TypeError(
4738
5223
  "Got an unexpected keyword argument '%s'"
4739
- " to method launch_apps" % key
5224
+ " to method list_adb_key_pod_bindings" % key
4740
5225
  )
4741
5226
  params[key] = val
4742
5227
  del params['kwargs']
4743
5228
  # verify the required parameter 'body' is set
4744
5229
  if self.api_client.client_side_validation and ('body' not in params or
4745
5230
  params['body'] is None): # noqa: E501
4746
- raise ValueError("Missing the required parameter `body` when calling `launch_apps`") # noqa: E501
5231
+ raise ValueError("Missing the required parameter `body` when calling `list_adb_key_pod_bindings`") # noqa: E501
4747
5232
 
4748
5233
  collection_formats = {}
4749
5234
 
@@ -4771,14 +5256,14 @@ class ACEPApi(object):
4771
5256
  auth_settings = ['volcengineSign'] # noqa: E501
4772
5257
 
4773
5258
  return self.api_client.call_api(
4774
- '/LaunchApps/2025-05-01/acep/post/application_json/', 'POST',
5259
+ '/ListAdbKeyPodBindings/2025-05-01/acep/post/application_json/', 'POST',
4775
5260
  path_params,
4776
5261
  query_params,
4777
5262
  header_params,
4778
5263
  body=body_params,
4779
5264
  post_params=form_params,
4780
5265
  files=local_var_files,
4781
- response_type='LaunchAppsResponse', # noqa: E501
5266
+ response_type='ListAdbKeyPodBindingsResponse', # noqa: E501
4782
5267
  auth_settings=auth_settings,
4783
5268
  async_req=params.get('async_req'),
4784
5269
  _return_http_data_only=params.get('_return_http_data_only'),
@@ -9054,6 +9539,103 @@ class ACEPApi(object):
9054
9539
  _request_timeout=params.get('_request_timeout'),
9055
9540
  collection_formats=collection_formats)
9056
9541
 
9542
+ def unbind_adb_key_pods(self, body, **kwargs): # noqa: E501
9543
+ """unbind_adb_key_pods # noqa: E501
9544
+
9545
+ This method makes a synchronous HTTP request by default. To make an
9546
+ asynchronous HTTP request, please pass async_req=True
9547
+ >>> thread = api.unbind_adb_key_pods(body, async_req=True)
9548
+ >>> result = thread.get()
9549
+
9550
+ :param async_req bool
9551
+ :param UnbindAdbKeyPodsRequest body: (required)
9552
+ :return: UnbindAdbKeyPodsResponse
9553
+ If the method is called asynchronously,
9554
+ returns the request thread.
9555
+ """
9556
+ kwargs['_return_http_data_only'] = True
9557
+ if kwargs.get('async_req'):
9558
+ return self.unbind_adb_key_pods_with_http_info(body, **kwargs) # noqa: E501
9559
+ else:
9560
+ (data) = self.unbind_adb_key_pods_with_http_info(body, **kwargs) # noqa: E501
9561
+ return data
9562
+
9563
+ def unbind_adb_key_pods_with_http_info(self, body, **kwargs): # noqa: E501
9564
+ """unbind_adb_key_pods # noqa: E501
9565
+
9566
+ This method makes a synchronous HTTP request by default. To make an
9567
+ asynchronous HTTP request, please pass async_req=True
9568
+ >>> thread = api.unbind_adb_key_pods_with_http_info(body, async_req=True)
9569
+ >>> result = thread.get()
9570
+
9571
+ :param async_req bool
9572
+ :param UnbindAdbKeyPodsRequest body: (required)
9573
+ :return: UnbindAdbKeyPodsResponse
9574
+ If the method is called asynchronously,
9575
+ returns the request thread.
9576
+ """
9577
+
9578
+ all_params = ['body'] # noqa: E501
9579
+ all_params.append('async_req')
9580
+ all_params.append('_return_http_data_only')
9581
+ all_params.append('_preload_content')
9582
+ all_params.append('_request_timeout')
9583
+
9584
+ params = locals()
9585
+ for key, val in six.iteritems(params['kwargs']):
9586
+ if key not in all_params:
9587
+ raise TypeError(
9588
+ "Got an unexpected keyword argument '%s'"
9589
+ " to method unbind_adb_key_pods" % key
9590
+ )
9591
+ params[key] = val
9592
+ del params['kwargs']
9593
+ # verify the required parameter 'body' is set
9594
+ if self.api_client.client_side_validation and ('body' not in params or
9595
+ params['body'] is None): # noqa: E501
9596
+ raise ValueError("Missing the required parameter `body` when calling `unbind_adb_key_pods`") # noqa: E501
9597
+
9598
+ collection_formats = {}
9599
+
9600
+ path_params = {}
9601
+
9602
+ query_params = []
9603
+
9604
+ header_params = {}
9605
+
9606
+ form_params = []
9607
+ local_var_files = {}
9608
+
9609
+ body_params = None
9610
+ if 'body' in params:
9611
+ body_params = params['body']
9612
+ # HTTP header `Accept`
9613
+ header_params['Accept'] = self.api_client.select_header_accept(
9614
+ ['application/json']) # noqa: E501
9615
+
9616
+ # HTTP header `Content-Type`
9617
+ header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
9618
+ ['application/json']) # noqa: E501
9619
+
9620
+ # Authentication setting
9621
+ auth_settings = ['volcengineSign'] # noqa: E501
9622
+
9623
+ return self.api_client.call_api(
9624
+ '/UnbindAdbKeyPods/2025-05-01/acep/post/application_json/', 'POST',
9625
+ path_params,
9626
+ query_params,
9627
+ header_params,
9628
+ body=body_params,
9629
+ post_params=form_params,
9630
+ files=local_var_files,
9631
+ response_type='UnbindAdbKeyPodsResponse', # noqa: E501
9632
+ auth_settings=auth_settings,
9633
+ async_req=params.get('async_req'),
9634
+ _return_http_data_only=params.get('_return_http_data_only'),
9635
+ _preload_content=params.get('_preload_content', True),
9636
+ _request_timeout=params.get('_request_timeout'),
9637
+ collection_formats=collection_formats)
9638
+
9057
9639
  def unbind_port_mapping_rule(self, body, **kwargs): # noqa: E501
9058
9640
  """unbind_port_mapping_rule # noqa: E501
9059
9641
 
@@ -9345,6 +9927,103 @@ class ACEPApi(object):
9345
9927
  _request_timeout=params.get('_request_timeout'),
9346
9928
  collection_formats=collection_formats)
9347
9929
 
9930
+ def update_adb_key(self, body, **kwargs): # noqa: E501
9931
+ """update_adb_key # noqa: E501
9932
+
9933
+ This method makes a synchronous HTTP request by default. To make an
9934
+ asynchronous HTTP request, please pass async_req=True
9935
+ >>> thread = api.update_adb_key(body, async_req=True)
9936
+ >>> result = thread.get()
9937
+
9938
+ :param async_req bool
9939
+ :param UpdateAdbKeyRequest body: (required)
9940
+ :return: UpdateAdbKeyResponse
9941
+ If the method is called asynchronously,
9942
+ returns the request thread.
9943
+ """
9944
+ kwargs['_return_http_data_only'] = True
9945
+ if kwargs.get('async_req'):
9946
+ return self.update_adb_key_with_http_info(body, **kwargs) # noqa: E501
9947
+ else:
9948
+ (data) = self.update_adb_key_with_http_info(body, **kwargs) # noqa: E501
9949
+ return data
9950
+
9951
+ def update_adb_key_with_http_info(self, body, **kwargs): # noqa: E501
9952
+ """update_adb_key # noqa: E501
9953
+
9954
+ This method makes a synchronous HTTP request by default. To make an
9955
+ asynchronous HTTP request, please pass async_req=True
9956
+ >>> thread = api.update_adb_key_with_http_info(body, async_req=True)
9957
+ >>> result = thread.get()
9958
+
9959
+ :param async_req bool
9960
+ :param UpdateAdbKeyRequest body: (required)
9961
+ :return: UpdateAdbKeyResponse
9962
+ If the method is called asynchronously,
9963
+ returns the request thread.
9964
+ """
9965
+
9966
+ all_params = ['body'] # noqa: E501
9967
+ all_params.append('async_req')
9968
+ all_params.append('_return_http_data_only')
9969
+ all_params.append('_preload_content')
9970
+ all_params.append('_request_timeout')
9971
+
9972
+ params = locals()
9973
+ for key, val in six.iteritems(params['kwargs']):
9974
+ if key not in all_params:
9975
+ raise TypeError(
9976
+ "Got an unexpected keyword argument '%s'"
9977
+ " to method update_adb_key" % key
9978
+ )
9979
+ params[key] = val
9980
+ del params['kwargs']
9981
+ # verify the required parameter 'body' is set
9982
+ if self.api_client.client_side_validation and ('body' not in params or
9983
+ params['body'] is None): # noqa: E501
9984
+ raise ValueError("Missing the required parameter `body` when calling `update_adb_key`") # noqa: E501
9985
+
9986
+ collection_formats = {}
9987
+
9988
+ path_params = {}
9989
+
9990
+ query_params = []
9991
+
9992
+ header_params = {}
9993
+
9994
+ form_params = []
9995
+ local_var_files = {}
9996
+
9997
+ body_params = None
9998
+ if 'body' in params:
9999
+ body_params = params['body']
10000
+ # HTTP header `Accept`
10001
+ header_params['Accept'] = self.api_client.select_header_accept(
10002
+ ['application/json']) # noqa: E501
10003
+
10004
+ # HTTP header `Content-Type`
10005
+ header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
10006
+ ['application/json']) # noqa: E501
10007
+
10008
+ # Authentication setting
10009
+ auth_settings = ['volcengineSign'] # noqa: E501
10010
+
10011
+ return self.api_client.call_api(
10012
+ '/UpdateAdbKey/2025-05-01/acep/post/application_json/', 'POST',
10013
+ path_params,
10014
+ query_params,
10015
+ header_params,
10016
+ body=body_params,
10017
+ post_params=form_params,
10018
+ files=local_var_files,
10019
+ response_type='UpdateAdbKeyResponse', # noqa: E501
10020
+ auth_settings=auth_settings,
10021
+ async_req=params.get('async_req'),
10022
+ _return_http_data_only=params.get('_return_http_data_only'),
10023
+ _preload_content=params.get('_preload_content', True),
10024
+ _request_timeout=params.get('_request_timeout'),
10025
+ collection_formats=collection_formats)
10026
+
9348
10027
  def update_aosp_image(self, body, **kwargs): # noqa: E501
9349
10028
  """update_aosp_image # noqa: E501
9350
10029