alibabacloud-fc20230330 4.1.6__py3-none-any.whl → 4.1.8__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 (9) hide show
  1. alibabacloud_fc20230330/__init__.py +1 -1
  2. alibabacloud_fc20230330/client.py +1082 -434
  3. alibabacloud_fc20230330/models.py +196 -11
  4. {alibabacloud_fc20230330-4.1.6.dist-info → alibabacloud_fc20230330-4.1.8.dist-info}/METADATA +1 -1
  5. alibabacloud_fc20230330-4.1.8.dist-info/RECORD +8 -0
  6. alibabacloud_fc20230330-4.1.6.dist-info/RECORD +0 -8
  7. {alibabacloud_fc20230330-4.1.6.dist-info → alibabacloud_fc20230330-4.1.8.dist-info}/LICENSE +0 -0
  8. {alibabacloud_fc20230330-4.1.6.dist-info → alibabacloud_fc20230330-4.1.8.dist-info}/WHEEL +0 -0
  9. {alibabacloud_fc20230330-4.1.6.dist-info → alibabacloud_fc20230330-4.1.8.dist-info}/top_level.txt +0 -0
alibabacloud_fc20230330/client.py CHANGED
@@ -72,10 +72,16 @@ class Client(OpenApiClient):
72
72
  req_body_type='json',
73
73
  body_type='json'
74
74
  )
75
- return TeaCore.from_map(
76
- fc20230330_models.CreateAliasResponse(),
77
- self.call_api(params, req, runtime)
78
- )
75
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
76
+ return TeaCore.from_map(
77
+ fc20230330_models.CreateAliasResponse(),
78
+ self.call_api(params, req, runtime)
79
+ )
80
+ else:
81
+ return TeaCore.from_map(
82
+ fc20230330_models.CreateAliasResponse(),
83
+ self.execute(params, req, runtime)
84
+ )
79
85
 
80
86
  async def create_alias_with_options_async(
81
87
  self,
@@ -108,10 +114,16 @@ class Client(OpenApiClient):
108
114
  req_body_type='json',
109
115
  body_type='json'
110
116
  )
111
- return TeaCore.from_map(
112
- fc20230330_models.CreateAliasResponse(),
113
- await self.call_api_async(params, req, runtime)
114
- )
117
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
118
+ return TeaCore.from_map(
119
+ fc20230330_models.CreateAliasResponse(),
120
+ await self.call_api_async(params, req, runtime)
121
+ )
122
+ else:
123
+ return TeaCore.from_map(
124
+ fc20230330_models.CreateAliasResponse(),
125
+ await self.execute_async(params, req, runtime)
126
+ )
115
127
 
116
128
  def create_alias(
117
129
  self,
@@ -175,10 +187,16 @@ class Client(OpenApiClient):
175
187
  req_body_type='json',
176
188
  body_type='json'
177
189
  )
178
- return TeaCore.from_map(
179
- fc20230330_models.CreateCustomDomainResponse(),
180
- self.call_api(params, req, runtime)
181
- )
190
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
191
+ return TeaCore.from_map(
192
+ fc20230330_models.CreateCustomDomainResponse(),
193
+ self.call_api(params, req, runtime)
194
+ )
195
+ else:
196
+ return TeaCore.from_map(
197
+ fc20230330_models.CreateCustomDomainResponse(),
198
+ self.execute(params, req, runtime)
199
+ )
182
200
 
183
201
  async def create_custom_domain_with_options_async(
184
202
  self,
@@ -212,10 +230,16 @@ class Client(OpenApiClient):
212
230
  req_body_type='json',
213
231
  body_type='json'
214
232
  )
215
- return TeaCore.from_map(
216
- fc20230330_models.CreateCustomDomainResponse(),
217
- await self.call_api_async(params, req, runtime)
218
- )
233
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
234
+ return TeaCore.from_map(
235
+ fc20230330_models.CreateCustomDomainResponse(),
236
+ await self.call_api_async(params, req, runtime)
237
+ )
238
+ else:
239
+ return TeaCore.from_map(
240
+ fc20230330_models.CreateCustomDomainResponse(),
241
+ await self.execute_async(params, req, runtime)
242
+ )
219
243
 
220
244
  def create_custom_domain(
221
245
  self,
@@ -281,10 +305,16 @@ class Client(OpenApiClient):
281
305
  req_body_type='json',
282
306
  body_type='json'
283
307
  )
284
- return TeaCore.from_map(
285
- fc20230330_models.CreateFunctionResponse(),
286
- self.call_api(params, req, runtime)
287
- )
308
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
309
+ return TeaCore.from_map(
310
+ fc20230330_models.CreateFunctionResponse(),
311
+ self.call_api(params, req, runtime)
312
+ )
313
+ else:
314
+ return TeaCore.from_map(
315
+ fc20230330_models.CreateFunctionResponse(),
316
+ self.execute(params, req, runtime)
317
+ )
288
318
 
289
319
  async def create_function_with_options_async(
290
320
  self,
@@ -318,10 +348,16 @@ class Client(OpenApiClient):
318
348
  req_body_type='json',
319
349
  body_type='json'
320
350
  )
321
- return TeaCore.from_map(
322
- fc20230330_models.CreateFunctionResponse(),
323
- await self.call_api_async(params, req, runtime)
324
- )
351
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
352
+ return TeaCore.from_map(
353
+ fc20230330_models.CreateFunctionResponse(),
354
+ await self.call_api_async(params, req, runtime)
355
+ )
356
+ else:
357
+ return TeaCore.from_map(
358
+ fc20230330_models.CreateFunctionResponse(),
359
+ await self.execute_async(params, req, runtime)
360
+ )
325
361
 
326
362
  def create_function(
327
363
  self,
@@ -386,10 +422,16 @@ class Client(OpenApiClient):
386
422
  req_body_type='json',
387
423
  body_type='json'
388
424
  )
389
- return TeaCore.from_map(
390
- fc20230330_models.CreateLayerVersionResponse(),
391
- self.call_api(params, req, runtime)
392
- )
425
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
426
+ return TeaCore.from_map(
427
+ fc20230330_models.CreateLayerVersionResponse(),
428
+ self.call_api(params, req, runtime)
429
+ )
430
+ else:
431
+ return TeaCore.from_map(
432
+ fc20230330_models.CreateLayerVersionResponse(),
433
+ self.execute(params, req, runtime)
434
+ )
393
435
 
394
436
  async def create_layer_version_with_options_async(
395
437
  self,
@@ -422,10 +464,16 @@ class Client(OpenApiClient):
422
464
  req_body_type='json',
423
465
  body_type='json'
424
466
  )
425
- return TeaCore.from_map(
426
- fc20230330_models.CreateLayerVersionResponse(),
427
- await self.call_api_async(params, req, runtime)
428
- )
467
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
468
+ return TeaCore.from_map(
469
+ fc20230330_models.CreateLayerVersionResponse(),
470
+ await self.call_api_async(params, req, runtime)
471
+ )
472
+ else:
473
+ return TeaCore.from_map(
474
+ fc20230330_models.CreateLayerVersionResponse(),
475
+ await self.execute_async(params, req, runtime)
476
+ )
429
477
 
430
478
  def create_layer_version(
431
479
  self,
@@ -488,10 +536,16 @@ class Client(OpenApiClient):
488
536
  req_body_type='json',
489
537
  body_type='json'
490
538
  )
491
- return TeaCore.from_map(
492
- fc20230330_models.CreateTriggerResponse(),
493
- self.call_api(params, req, runtime)
494
- )
539
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
540
+ return TeaCore.from_map(
541
+ fc20230330_models.CreateTriggerResponse(),
542
+ self.call_api(params, req, runtime)
543
+ )
544
+ else:
545
+ return TeaCore.from_map(
546
+ fc20230330_models.CreateTriggerResponse(),
547
+ self.execute(params, req, runtime)
548
+ )
495
549
 
496
550
  async def create_trigger_with_options_async(
497
551
  self,
@@ -524,10 +578,16 @@ class Client(OpenApiClient):
524
578
  req_body_type='json',
525
579
  body_type='json'
526
580
  )
527
- return TeaCore.from_map(
528
- fc20230330_models.CreateTriggerResponse(),
529
- await self.call_api_async(params, req, runtime)
530
- )
581
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
582
+ return TeaCore.from_map(
583
+ fc20230330_models.CreateTriggerResponse(),
584
+ await self.call_api_async(params, req, runtime)
585
+ )
586
+ else:
587
+ return TeaCore.from_map(
588
+ fc20230330_models.CreateTriggerResponse(),
589
+ await self.execute_async(params, req, runtime)
590
+ )
531
591
 
532
592
  def create_trigger(
533
593
  self,
@@ -590,10 +650,16 @@ class Client(OpenApiClient):
590
650
  req_body_type='json',
591
651
  body_type='none'
592
652
  )
593
- return TeaCore.from_map(
594
- fc20230330_models.CreateVpcBindingResponse(),
595
- self.call_api(params, req, runtime)
596
- )
653
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
654
+ return TeaCore.from_map(
655
+ fc20230330_models.CreateVpcBindingResponse(),
656
+ self.call_api(params, req, runtime)
657
+ )
658
+ else:
659
+ return TeaCore.from_map(
660
+ fc20230330_models.CreateVpcBindingResponse(),
661
+ self.execute(params, req, runtime)
662
+ )
597
663
 
598
664
  async def create_vpc_binding_with_options_async(
599
665
  self,
@@ -626,10 +692,16 @@ class Client(OpenApiClient):
626
692
  req_body_type='json',
627
693
  body_type='none'
628
694
  )
629
- return TeaCore.from_map(
630
- fc20230330_models.CreateVpcBindingResponse(),
631
- await self.call_api_async(params, req, runtime)
632
- )
695
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
696
+ return TeaCore.from_map(
697
+ fc20230330_models.CreateVpcBindingResponse(),
698
+ await self.call_api_async(params, req, runtime)
699
+ )
700
+ else:
701
+ return TeaCore.from_map(
702
+ fc20230330_models.CreateVpcBindingResponse(),
703
+ await self.execute_async(params, req, runtime)
704
+ )
633
705
 
634
706
  def create_vpc_binding(
635
707
  self,
@@ -689,10 +761,16 @@ class Client(OpenApiClient):
689
761
  req_body_type='json',
690
762
  body_type='none'
691
763
  )
692
- return TeaCore.from_map(
693
- fc20230330_models.DeleteAliasResponse(),
694
- self.call_api(params, req, runtime)
695
- )
764
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
765
+ return TeaCore.from_map(
766
+ fc20230330_models.DeleteAliasResponse(),
767
+ self.call_api(params, req, runtime)
768
+ )
769
+ else:
770
+ return TeaCore.from_map(
771
+ fc20230330_models.DeleteAliasResponse(),
772
+ self.execute(params, req, runtime)
773
+ )
696
774
 
697
775
  async def delete_alias_with_options_async(
698
776
  self,
@@ -722,10 +800,16 @@ class Client(OpenApiClient):
722
800
  req_body_type='json',
723
801
  body_type='none'
724
802
  )
725
- return TeaCore.from_map(
726
- fc20230330_models.DeleteAliasResponse(),
727
- await self.call_api_async(params, req, runtime)
728
- )
803
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
804
+ return TeaCore.from_map(
805
+ fc20230330_models.DeleteAliasResponse(),
806
+ await self.call_api_async(params, req, runtime)
807
+ )
808
+ else:
809
+ return TeaCore.from_map(
810
+ fc20230330_models.DeleteAliasResponse(),
811
+ await self.execute_async(params, req, runtime)
812
+ )
729
813
 
730
814
  def delete_alias(
731
815
  self,
@@ -789,10 +873,16 @@ class Client(OpenApiClient):
789
873
  req_body_type='json',
790
874
  body_type='none'
791
875
  )
792
- return TeaCore.from_map(
793
- fc20230330_models.DeleteAsyncInvokeConfigResponse(),
794
- self.call_api(params, req, runtime)
795
- )
876
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
877
+ return TeaCore.from_map(
878
+ fc20230330_models.DeleteAsyncInvokeConfigResponse(),
879
+ self.call_api(params, req, runtime)
880
+ )
881
+ else:
882
+ return TeaCore.from_map(
883
+ fc20230330_models.DeleteAsyncInvokeConfigResponse(),
884
+ self.execute(params, req, runtime)
885
+ )
796
886
 
797
887
  async def delete_async_invoke_config_with_options_async(
798
888
  self,
@@ -828,10 +918,16 @@ class Client(OpenApiClient):
828
918
  req_body_type='json',
829
919
  body_type='none'
830
920
  )
831
- return TeaCore.from_map(
832
- fc20230330_models.DeleteAsyncInvokeConfigResponse(),
833
- await self.call_api_async(params, req, runtime)
834
- )
921
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
922
+ return TeaCore.from_map(
923
+ fc20230330_models.DeleteAsyncInvokeConfigResponse(),
924
+ await self.call_api_async(params, req, runtime)
925
+ )
926
+ else:
927
+ return TeaCore.from_map(
928
+ fc20230330_models.DeleteAsyncInvokeConfigResponse(),
929
+ await self.execute_async(params, req, runtime)
930
+ )
835
931
 
836
932
  def delete_async_invoke_config(
837
933
  self,
@@ -890,10 +986,16 @@ class Client(OpenApiClient):
890
986
  req_body_type='json',
891
987
  body_type='none'
892
988
  )
893
- return TeaCore.from_map(
894
- fc20230330_models.DeleteConcurrencyConfigResponse(),
895
- self.call_api(params, req, runtime)
896
- )
989
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
990
+ return TeaCore.from_map(
991
+ fc20230330_models.DeleteConcurrencyConfigResponse(),
992
+ self.call_api(params, req, runtime)
993
+ )
994
+ else:
995
+ return TeaCore.from_map(
996
+ fc20230330_models.DeleteConcurrencyConfigResponse(),
997
+ self.execute(params, req, runtime)
998
+ )
897
999
 
898
1000
  async def delete_concurrency_config_with_options_async(
899
1001
  self,
@@ -922,10 +1024,16 @@ class Client(OpenApiClient):
922
1024
  req_body_type='json',
923
1025
  body_type='none'
924
1026
  )
925
- return TeaCore.from_map(
926
- fc20230330_models.DeleteConcurrencyConfigResponse(),
927
- await self.call_api_async(params, req, runtime)
928
- )
1027
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1028
+ return TeaCore.from_map(
1029
+ fc20230330_models.DeleteConcurrencyConfigResponse(),
1030
+ await self.call_api_async(params, req, runtime)
1031
+ )
1032
+ else:
1033
+ return TeaCore.from_map(
1034
+ fc20230330_models.DeleteConcurrencyConfigResponse(),
1035
+ await self.execute_async(params, req, runtime)
1036
+ )
929
1037
 
930
1038
  def delete_concurrency_config(
931
1039
  self,
@@ -980,10 +1088,16 @@ class Client(OpenApiClient):
980
1088
  req_body_type='json',
981
1089
  body_type='none'
982
1090
  )
983
- return TeaCore.from_map(
984
- fc20230330_models.DeleteCustomDomainResponse(),
985
- self.call_api(params, req, runtime)
986
- )
1091
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1092
+ return TeaCore.from_map(
1093
+ fc20230330_models.DeleteCustomDomainResponse(),
1094
+ self.call_api(params, req, runtime)
1095
+ )
1096
+ else:
1097
+ return TeaCore.from_map(
1098
+ fc20230330_models.DeleteCustomDomainResponse(),
1099
+ self.execute(params, req, runtime)
1100
+ )
987
1101
 
988
1102
  async def delete_custom_domain_with_options_async(
989
1103
  self,
@@ -1012,10 +1126,16 @@ class Client(OpenApiClient):
1012
1126
  req_body_type='json',
1013
1127
  body_type='none'
1014
1128
  )
1015
- return TeaCore.from_map(
1016
- fc20230330_models.DeleteCustomDomainResponse(),
1017
- await self.call_api_async(params, req, runtime)
1018
- )
1129
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1130
+ return TeaCore.from_map(
1131
+ fc20230330_models.DeleteCustomDomainResponse(),
1132
+ await self.call_api_async(params, req, runtime)
1133
+ )
1134
+ else:
1135
+ return TeaCore.from_map(
1136
+ fc20230330_models.DeleteCustomDomainResponse(),
1137
+ await self.execute_async(params, req, runtime)
1138
+ )
1019
1139
 
1020
1140
  def delete_custom_domain(
1021
1141
  self,
@@ -1070,10 +1190,16 @@ class Client(OpenApiClient):
1070
1190
  req_body_type='json',
1071
1191
  body_type='none'
1072
1192
  )
1073
- return TeaCore.from_map(
1074
- fc20230330_models.DeleteFunctionResponse(),
1075
- self.call_api(params, req, runtime)
1076
- )
1193
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1194
+ return TeaCore.from_map(
1195
+ fc20230330_models.DeleteFunctionResponse(),
1196
+ self.call_api(params, req, runtime)
1197
+ )
1198
+ else:
1199
+ return TeaCore.from_map(
1200
+ fc20230330_models.DeleteFunctionResponse(),
1201
+ self.execute(params, req, runtime)
1202
+ )
1077
1203
 
1078
1204
  async def delete_function_with_options_async(
1079
1205
  self,
@@ -1102,10 +1228,16 @@ class Client(OpenApiClient):
1102
1228
  req_body_type='json',
1103
1229
  body_type='none'
1104
1230
  )
1105
- return TeaCore.from_map(
1106
- fc20230330_models.DeleteFunctionResponse(),
1107
- await self.call_api_async(params, req, runtime)
1108
- )
1231
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1232
+ return TeaCore.from_map(
1233
+ fc20230330_models.DeleteFunctionResponse(),
1234
+ await self.call_api_async(params, req, runtime)
1235
+ )
1236
+ else:
1237
+ return TeaCore.from_map(
1238
+ fc20230330_models.DeleteFunctionResponse(),
1239
+ await self.execute_async(params, req, runtime)
1240
+ )
1109
1241
 
1110
1242
  def delete_function(
1111
1243
  self,
@@ -1141,7 +1273,7 @@ class Client(OpenApiClient):
1141
1273
  runtime: util_models.RuntimeOptions,
1142
1274
  ) -> fc20230330_models.DeleteFunctionVersionResponse:
1143
1275
  """
1144
- @summary Deletes a function version.
1276
+ @summary http://pre.hhht/#vpc
1145
1277
 
1146
1278
  @param headers: map
1147
1279
  @param runtime: runtime options for this request RuntimeOptions
@@ -1161,10 +1293,16 @@ class Client(OpenApiClient):
1161
1293
  req_body_type='json',
1162
1294
  body_type='none'
1163
1295
  )
1164
- return TeaCore.from_map(
1165
- fc20230330_models.DeleteFunctionVersionResponse(),
1166
- self.call_api(params, req, runtime)
1167
- )
1296
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1297
+ return TeaCore.from_map(
1298
+ fc20230330_models.DeleteFunctionVersionResponse(),
1299
+ self.call_api(params, req, runtime)
1300
+ )
1301
+ else:
1302
+ return TeaCore.from_map(
1303
+ fc20230330_models.DeleteFunctionVersionResponse(),
1304
+ self.execute(params, req, runtime)
1305
+ )
1168
1306
 
1169
1307
  async def delete_function_version_with_options_async(
1170
1308
  self,
@@ -1174,7 +1312,7 @@ class Client(OpenApiClient):
1174
1312
  runtime: util_models.RuntimeOptions,
1175
1313
  ) -> fc20230330_models.DeleteFunctionVersionResponse:
1176
1314
  """
1177
- @summary Deletes a function version.
1315
+ @summary http://pre.hhht/#vpc
1178
1316
 
1179
1317
  @param headers: map
1180
1318
  @param runtime: runtime options for this request RuntimeOptions
@@ -1194,10 +1332,16 @@ class Client(OpenApiClient):
1194
1332
  req_body_type='json',
1195
1333
  body_type='none'
1196
1334
  )
1197
- return TeaCore.from_map(
1198
- fc20230330_models.DeleteFunctionVersionResponse(),
1199
- await self.call_api_async(params, req, runtime)
1200
- )
1335
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1336
+ return TeaCore.from_map(
1337
+ fc20230330_models.DeleteFunctionVersionResponse(),
1338
+ await self.call_api_async(params, req, runtime)
1339
+ )
1340
+ else:
1341
+ return TeaCore.from_map(
1342
+ fc20230330_models.DeleteFunctionVersionResponse(),
1343
+ await self.execute_async(params, req, runtime)
1344
+ )
1201
1345
 
1202
1346
  def delete_function_version(
1203
1347
  self,
@@ -1205,7 +1349,7 @@ class Client(OpenApiClient):
1205
1349
  version_id: str,
1206
1350
  ) -> fc20230330_models.DeleteFunctionVersionResponse:
1207
1351
  """
1208
- @summary Deletes a function version.
1352
+ @summary http://pre.hhht/#vpc
1209
1353
 
1210
1354
  @return: DeleteFunctionVersionResponse
1211
1355
  """
@@ -1219,7 +1363,7 @@ class Client(OpenApiClient):
1219
1363
  version_id: str,
1220
1364
  ) -> fc20230330_models.DeleteFunctionVersionResponse:
1221
1365
  """
1222
- @summary Deletes a function version.
1366
+ @summary http://pre.hhht/#vpc
1223
1367
 
1224
1368
  @return: DeleteFunctionVersionResponse
1225
1369
  """
@@ -1255,10 +1399,16 @@ class Client(OpenApiClient):
1255
1399
  req_body_type='json',
1256
1400
  body_type='none'
1257
1401
  )
1258
- return TeaCore.from_map(
1259
- fc20230330_models.DeleteLayerVersionResponse(),
1260
- self.call_api(params, req, runtime)
1261
- )
1402
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1403
+ return TeaCore.from_map(
1404
+ fc20230330_models.DeleteLayerVersionResponse(),
1405
+ self.call_api(params, req, runtime)
1406
+ )
1407
+ else:
1408
+ return TeaCore.from_map(
1409
+ fc20230330_models.DeleteLayerVersionResponse(),
1410
+ self.execute(params, req, runtime)
1411
+ )
1262
1412
 
1263
1413
  async def delete_layer_version_with_options_async(
1264
1414
  self,
@@ -1288,10 +1438,16 @@ class Client(OpenApiClient):
1288
1438
  req_body_type='json',
1289
1439
  body_type='none'
1290
1440
  )
1291
- return TeaCore.from_map(
1292
- fc20230330_models.DeleteLayerVersionResponse(),
1293
- await self.call_api_async(params, req, runtime)
1294
- )
1441
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1442
+ return TeaCore.from_map(
1443
+ fc20230330_models.DeleteLayerVersionResponse(),
1444
+ await self.call_api_async(params, req, runtime)
1445
+ )
1446
+ else:
1447
+ return TeaCore.from_map(
1448
+ fc20230330_models.DeleteLayerVersionResponse(),
1449
+ await self.execute_async(params, req, runtime)
1450
+ )
1295
1451
 
1296
1452
  def delete_layer_version(
1297
1453
  self,
@@ -1355,10 +1511,16 @@ class Client(OpenApiClient):
1355
1511
  req_body_type='json',
1356
1512
  body_type='none'
1357
1513
  )
1358
- return TeaCore.from_map(
1359
- fc20230330_models.DeleteProvisionConfigResponse(),
1360
- self.call_api(params, req, runtime)
1361
- )
1514
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1515
+ return TeaCore.from_map(
1516
+ fc20230330_models.DeleteProvisionConfigResponse(),
1517
+ self.call_api(params, req, runtime)
1518
+ )
1519
+ else:
1520
+ return TeaCore.from_map(
1521
+ fc20230330_models.DeleteProvisionConfigResponse(),
1522
+ self.execute(params, req, runtime)
1523
+ )
1362
1524
 
1363
1525
  async def delete_provision_config_with_options_async(
1364
1526
  self,
@@ -1394,10 +1556,16 @@ class Client(OpenApiClient):
1394
1556
  req_body_type='json',
1395
1557
  body_type='none'
1396
1558
  )
1397
- return TeaCore.from_map(
1398
- fc20230330_models.DeleteProvisionConfigResponse(),
1399
- await self.call_api_async(params, req, runtime)
1400
- )
1559
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1560
+ return TeaCore.from_map(
1561
+ fc20230330_models.DeleteProvisionConfigResponse(),
1562
+ await self.call_api_async(params, req, runtime)
1563
+ )
1564
+ else:
1565
+ return TeaCore.from_map(
1566
+ fc20230330_models.DeleteProvisionConfigResponse(),
1567
+ await self.execute_async(params, req, runtime)
1568
+ )
1401
1569
 
1402
1570
  def delete_provision_config(
1403
1571
  self,
@@ -1457,10 +1625,16 @@ class Client(OpenApiClient):
1457
1625
  req_body_type='json',
1458
1626
  body_type='none'
1459
1627
  )
1460
- return TeaCore.from_map(
1461
- fc20230330_models.DeleteTriggerResponse(),
1462
- self.call_api(params, req, runtime)
1463
- )
1628
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1629
+ return TeaCore.from_map(
1630
+ fc20230330_models.DeleteTriggerResponse(),
1631
+ self.call_api(params, req, runtime)
1632
+ )
1633
+ else:
1634
+ return TeaCore.from_map(
1635
+ fc20230330_models.DeleteTriggerResponse(),
1636
+ self.execute(params, req, runtime)
1637
+ )
1464
1638
 
1465
1639
  async def delete_trigger_with_options_async(
1466
1640
  self,
@@ -1490,10 +1664,16 @@ class Client(OpenApiClient):
1490
1664
  req_body_type='json',
1491
1665
  body_type='none'
1492
1666
  )
1493
- return TeaCore.from_map(
1494
- fc20230330_models.DeleteTriggerResponse(),
1495
- await self.call_api_async(params, req, runtime)
1496
- )
1667
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1668
+ return TeaCore.from_map(
1669
+ fc20230330_models.DeleteTriggerResponse(),
1670
+ await self.call_api_async(params, req, runtime)
1671
+ )
1672
+ else:
1673
+ return TeaCore.from_map(
1674
+ fc20230330_models.DeleteTriggerResponse(),
1675
+ await self.execute_async(params, req, runtime)
1676
+ )
1497
1677
 
1498
1678
  def delete_trigger(
1499
1679
  self,
@@ -1551,10 +1731,16 @@ class Client(OpenApiClient):
1551
1731
  req_body_type='json',
1552
1732
  body_type='none'
1553
1733
  )
1554
- return TeaCore.from_map(
1555
- fc20230330_models.DeleteVpcBindingResponse(),
1556
- self.call_api(params, req, runtime)
1557
- )
1734
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1735
+ return TeaCore.from_map(
1736
+ fc20230330_models.DeleteVpcBindingResponse(),
1737
+ self.call_api(params, req, runtime)
1738
+ )
1739
+ else:
1740
+ return TeaCore.from_map(
1741
+ fc20230330_models.DeleteVpcBindingResponse(),
1742
+ self.execute(params, req, runtime)
1743
+ )
1558
1744
 
1559
1745
  async def delete_vpc_binding_with_options_async(
1560
1746
  self,
@@ -1584,10 +1770,16 @@ class Client(OpenApiClient):
1584
1770
  req_body_type='json',
1585
1771
  body_type='none'
1586
1772
  )
1587
- return TeaCore.from_map(
1588
- fc20230330_models.DeleteVpcBindingResponse(),
1589
- await self.call_api_async(params, req, runtime)
1590
- )
1773
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1774
+ return TeaCore.from_map(
1775
+ fc20230330_models.DeleteVpcBindingResponse(),
1776
+ await self.call_api_async(params, req, runtime)
1777
+ )
1778
+ else:
1779
+ return TeaCore.from_map(
1780
+ fc20230330_models.DeleteVpcBindingResponse(),
1781
+ await self.execute_async(params, req, runtime)
1782
+ )
1591
1783
 
1592
1784
  def delete_vpc_binding(
1593
1785
  self,
@@ -1645,10 +1837,16 @@ class Client(OpenApiClient):
1645
1837
  req_body_type='json',
1646
1838
  body_type='json'
1647
1839
  )
1648
- return TeaCore.from_map(
1649
- fc20230330_models.GetAliasResponse(),
1650
- self.call_api(params, req, runtime)
1651
- )
1840
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1841
+ return TeaCore.from_map(
1842
+ fc20230330_models.GetAliasResponse(),
1843
+ self.call_api(params, req, runtime)
1844
+ )
1845
+ else:
1846
+ return TeaCore.from_map(
1847
+ fc20230330_models.GetAliasResponse(),
1848
+ self.execute(params, req, runtime)
1849
+ )
1652
1850
 
1653
1851
  async def get_alias_with_options_async(
1654
1852
  self,
@@ -1678,10 +1876,16 @@ class Client(OpenApiClient):
1678
1876
  req_body_type='json',
1679
1877
  body_type='json'
1680
1878
  )
1681
- return TeaCore.from_map(
1682
- fc20230330_models.GetAliasResponse(),
1683
- await self.call_api_async(params, req, runtime)
1684
- )
1879
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1880
+ return TeaCore.from_map(
1881
+ fc20230330_models.GetAliasResponse(),
1882
+ await self.call_api_async(params, req, runtime)
1883
+ )
1884
+ else:
1885
+ return TeaCore.from_map(
1886
+ fc20230330_models.GetAliasResponse(),
1887
+ await self.execute_async(params, req, runtime)
1888
+ )
1685
1889
 
1686
1890
  def get_alias(
1687
1891
  self,
@@ -1745,10 +1949,16 @@ class Client(OpenApiClient):
1745
1949
  req_body_type='json',
1746
1950
  body_type='json'
1747
1951
  )
1748
- return TeaCore.from_map(
1749
- fc20230330_models.GetAsyncInvokeConfigResponse(),
1750
- self.call_api(params, req, runtime)
1751
- )
1952
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1953
+ return TeaCore.from_map(
1954
+ fc20230330_models.GetAsyncInvokeConfigResponse(),
1955
+ self.call_api(params, req, runtime)
1956
+ )
1957
+ else:
1958
+ return TeaCore.from_map(
1959
+ fc20230330_models.GetAsyncInvokeConfigResponse(),
1960
+ self.execute(params, req, runtime)
1961
+ )
1752
1962
 
1753
1963
  async def get_async_invoke_config_with_options_async(
1754
1964
  self,
@@ -1784,10 +1994,16 @@ class Client(OpenApiClient):
1784
1994
  req_body_type='json',
1785
1995
  body_type='json'
1786
1996
  )
1787
- return TeaCore.from_map(
1788
- fc20230330_models.GetAsyncInvokeConfigResponse(),
1789
- await self.call_api_async(params, req, runtime)
1790
- )
1997
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
1998
+ return TeaCore.from_map(
1999
+ fc20230330_models.GetAsyncInvokeConfigResponse(),
2000
+ await self.call_api_async(params, req, runtime)
2001
+ )
2002
+ else:
2003
+ return TeaCore.from_map(
2004
+ fc20230330_models.GetAsyncInvokeConfigResponse(),
2005
+ await self.execute_async(params, req, runtime)
2006
+ )
1791
2007
 
1792
2008
  def get_async_invoke_config(
1793
2009
  self,
@@ -1854,10 +2070,16 @@ class Client(OpenApiClient):
1854
2070
  req_body_type='json',
1855
2071
  body_type='json'
1856
2072
  )
1857
- return TeaCore.from_map(
1858
- fc20230330_models.GetAsyncTaskResponse(),
1859
- self.call_api(params, req, runtime)
1860
- )
2073
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2074
+ return TeaCore.from_map(
2075
+ fc20230330_models.GetAsyncTaskResponse(),
2076
+ self.call_api(params, req, runtime)
2077
+ )
2078
+ else:
2079
+ return TeaCore.from_map(
2080
+ fc20230330_models.GetAsyncTaskResponse(),
2081
+ self.execute(params, req, runtime)
2082
+ )
1861
2083
 
1862
2084
  async def get_async_task_with_options_async(
1863
2085
  self,
@@ -1894,10 +2116,16 @@ class Client(OpenApiClient):
1894
2116
  req_body_type='json',
1895
2117
  body_type='json'
1896
2118
  )
1897
- return TeaCore.from_map(
1898
- fc20230330_models.GetAsyncTaskResponse(),
1899
- await self.call_api_async(params, req, runtime)
1900
- )
2119
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2120
+ return TeaCore.from_map(
2121
+ fc20230330_models.GetAsyncTaskResponse(),
2122
+ await self.call_api_async(params, req, runtime)
2123
+ )
2124
+ else:
2125
+ return TeaCore.from_map(
2126
+ fc20230330_models.GetAsyncTaskResponse(),
2127
+ await self.execute_async(params, req, runtime)
2128
+ )
1901
2129
 
1902
2130
  def get_async_task(
1903
2131
  self,
@@ -1958,10 +2186,16 @@ class Client(OpenApiClient):
1958
2186
  req_body_type='json',
1959
2187
  body_type='json'
1960
2188
  )
1961
- return TeaCore.from_map(
1962
- fc20230330_models.GetConcurrencyConfigResponse(),
1963
- self.call_api(params, req, runtime)
1964
- )
2189
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2190
+ return TeaCore.from_map(
2191
+ fc20230330_models.GetConcurrencyConfigResponse(),
2192
+ self.call_api(params, req, runtime)
2193
+ )
2194
+ else:
2195
+ return TeaCore.from_map(
2196
+ fc20230330_models.GetConcurrencyConfigResponse(),
2197
+ self.execute(params, req, runtime)
2198
+ )
1965
2199
 
1966
2200
  async def get_concurrency_config_with_options_async(
1967
2201
  self,
@@ -1990,10 +2224,16 @@ class Client(OpenApiClient):
1990
2224
  req_body_type='json',
1991
2225
  body_type='json'
1992
2226
  )
1993
- return TeaCore.from_map(
1994
- fc20230330_models.GetConcurrencyConfigResponse(),
1995
- await self.call_api_async(params, req, runtime)
1996
- )
2227
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2228
+ return TeaCore.from_map(
2229
+ fc20230330_models.GetConcurrencyConfigResponse(),
2230
+ await self.call_api_async(params, req, runtime)
2231
+ )
2232
+ else:
2233
+ return TeaCore.from_map(
2234
+ fc20230330_models.GetConcurrencyConfigResponse(),
2235
+ await self.execute_async(params, req, runtime)
2236
+ )
1997
2237
 
1998
2238
  def get_concurrency_config(
1999
2239
  self,
@@ -2048,10 +2288,16 @@ class Client(OpenApiClient):
2048
2288
  req_body_type='json',
2049
2289
  body_type='json'
2050
2290
  )
2051
- return TeaCore.from_map(
2052
- fc20230330_models.GetCustomDomainResponse(),
2053
- self.call_api(params, req, runtime)
2054
- )
2291
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2292
+ return TeaCore.from_map(
2293
+ fc20230330_models.GetCustomDomainResponse(),
2294
+ self.call_api(params, req, runtime)
2295
+ )
2296
+ else:
2297
+ return TeaCore.from_map(
2298
+ fc20230330_models.GetCustomDomainResponse(),
2299
+ self.execute(params, req, runtime)
2300
+ )
2055
2301
 
2056
2302
  async def get_custom_domain_with_options_async(
2057
2303
  self,
@@ -2080,10 +2326,16 @@ class Client(OpenApiClient):
2080
2326
  req_body_type='json',
2081
2327
  body_type='json'
2082
2328
  )
2083
- return TeaCore.from_map(
2084
- fc20230330_models.GetCustomDomainResponse(),
2085
- await self.call_api_async(params, req, runtime)
2086
- )
2329
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2330
+ return TeaCore.from_map(
2331
+ fc20230330_models.GetCustomDomainResponse(),
2332
+ await self.call_api_async(params, req, runtime)
2333
+ )
2334
+ else:
2335
+ return TeaCore.from_map(
2336
+ fc20230330_models.GetCustomDomainResponse(),
2337
+ await self.execute_async(params, req, runtime)
2338
+ )
2087
2339
 
2088
2340
  def get_custom_domain(
2089
2341
  self,
@@ -2145,10 +2397,16 @@ class Client(OpenApiClient):
2145
2397
  req_body_type='json',
2146
2398
  body_type='json'
2147
2399
  )
2148
- return TeaCore.from_map(
2149
- fc20230330_models.GetFunctionResponse(),
2150
- self.call_api(params, req, runtime)
2151
- )
2400
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2401
+ return TeaCore.from_map(
2402
+ fc20230330_models.GetFunctionResponse(),
2403
+ self.call_api(params, req, runtime)
2404
+ )
2405
+ else:
2406
+ return TeaCore.from_map(
2407
+ fc20230330_models.GetFunctionResponse(),
2408
+ self.execute(params, req, runtime)
2409
+ )
2152
2410
 
2153
2411
  async def get_function_with_options_async(
2154
2412
  self,
@@ -2184,10 +2442,16 @@ class Client(OpenApiClient):
2184
2442
  req_body_type='json',
2185
2443
  body_type='json'
2186
2444
  )
2187
- return TeaCore.from_map(
2188
- fc20230330_models.GetFunctionResponse(),
2189
- await self.call_api_async(params, req, runtime)
2190
- )
2445
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2446
+ return TeaCore.from_map(
2447
+ fc20230330_models.GetFunctionResponse(),
2448
+ await self.call_api_async(params, req, runtime)
2449
+ )
2450
+ else:
2451
+ return TeaCore.from_map(
2452
+ fc20230330_models.GetFunctionResponse(),
2453
+ await self.execute_async(params, req, runtime)
2454
+ )
2191
2455
 
2192
2456
  def get_function(
2193
2457
  self,
@@ -2253,10 +2517,16 @@ class Client(OpenApiClient):
2253
2517
  req_body_type='json',
2254
2518
  body_type='json'
2255
2519
  )
2256
- return TeaCore.from_map(
2257
- fc20230330_models.GetFunctionCodeResponse(),
2258
- self.call_api(params, req, runtime)
2259
- )
2520
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2521
+ return TeaCore.from_map(
2522
+ fc20230330_models.GetFunctionCodeResponse(),
2523
+ self.call_api(params, req, runtime)
2524
+ )
2525
+ else:
2526
+ return TeaCore.from_map(
2527
+ fc20230330_models.GetFunctionCodeResponse(),
2528
+ self.execute(params, req, runtime)
2529
+ )
2260
2530
 
2261
2531
  async def get_function_code_with_options_async(
2262
2532
  self,
@@ -2292,10 +2562,16 @@ class Client(OpenApiClient):
2292
2562
  req_body_type='json',
2293
2563
  body_type='json'
2294
2564
  )
2295
- return TeaCore.from_map(
2296
- fc20230330_models.GetFunctionCodeResponse(),
2297
- await self.call_api_async(params, req, runtime)
2298
- )
2565
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2566
+ return TeaCore.from_map(
2567
+ fc20230330_models.GetFunctionCodeResponse(),
2568
+ await self.call_api_async(params, req, runtime)
2569
+ )
2570
+ else:
2571
+ return TeaCore.from_map(
2572
+ fc20230330_models.GetFunctionCodeResponse(),
2573
+ await self.execute_async(params, req, runtime)
2574
+ )
2299
2575
 
2300
2576
  def get_function_code(
2301
2577
  self,
@@ -2355,10 +2631,16 @@ class Client(OpenApiClient):
2355
2631
  req_body_type='json',
2356
2632
  body_type='json'
2357
2633
  )
2358
- return TeaCore.from_map(
2359
- fc20230330_models.GetLayerVersionResponse(),
2360
- self.call_api(params, req, runtime)
2361
- )
2634
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2635
+ return TeaCore.from_map(
2636
+ fc20230330_models.GetLayerVersionResponse(),
2637
+ self.call_api(params, req, runtime)
2638
+ )
2639
+ else:
2640
+ return TeaCore.from_map(
2641
+ fc20230330_models.GetLayerVersionResponse(),
2642
+ self.execute(params, req, runtime)
2643
+ )
2362
2644
 
2363
2645
  async def get_layer_version_with_options_async(
2364
2646
  self,
@@ -2388,10 +2670,16 @@ class Client(OpenApiClient):
2388
2670
  req_body_type='json',
2389
2671
  body_type='json'
2390
2672
  )
2391
- return TeaCore.from_map(
2392
- fc20230330_models.GetLayerVersionResponse(),
2393
- await self.call_api_async(params, req, runtime)
2394
- )
2673
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2674
+ return TeaCore.from_map(
2675
+ fc20230330_models.GetLayerVersionResponse(),
2676
+ await self.call_api_async(params, req, runtime)
2677
+ )
2678
+ else:
2679
+ return TeaCore.from_map(
2680
+ fc20230330_models.GetLayerVersionResponse(),
2681
+ await self.execute_async(params, req, runtime)
2682
+ )
2395
2683
 
2396
2684
  def get_layer_version(
2397
2685
  self,
@@ -2448,10 +2736,16 @@ class Client(OpenApiClient):
2448
2736
  req_body_type='json',
2449
2737
  body_type='json'
2450
2738
  )
2451
- return TeaCore.from_map(
2452
- fc20230330_models.GetLayerVersionByArnResponse(),
2453
- self.call_api(params, req, runtime)
2454
- )
2739
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2740
+ return TeaCore.from_map(
2741
+ fc20230330_models.GetLayerVersionByArnResponse(),
2742
+ self.call_api(params, req, runtime)
2743
+ )
2744
+ else:
2745
+ return TeaCore.from_map(
2746
+ fc20230330_models.GetLayerVersionByArnResponse(),
2747
+ self.execute(params, req, runtime)
2748
+ )
2455
2749
 
2456
2750
  async def get_layer_version_by_arn_with_options_async(
2457
2751
  self,
@@ -2480,10 +2774,16 @@ class Client(OpenApiClient):
2480
2774
  req_body_type='json',
2481
2775
  body_type='json'
2482
2776
  )
2483
- return TeaCore.from_map(
2484
- fc20230330_models.GetLayerVersionByArnResponse(),
2485
- await self.call_api_async(params, req, runtime)
2486
- )
2777
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2778
+ return TeaCore.from_map(
2779
+ fc20230330_models.GetLayerVersionByArnResponse(),
2780
+ await self.call_api_async(params, req, runtime)
2781
+ )
2782
+ else:
2783
+ return TeaCore.from_map(
2784
+ fc20230330_models.GetLayerVersionByArnResponse(),
2785
+ await self.execute_async(params, req, runtime)
2786
+ )
2487
2787
 
2488
2788
  def get_layer_version_by_arn(
2489
2789
  self,
@@ -2545,10 +2845,16 @@ class Client(OpenApiClient):
2545
2845
  req_body_type='json',
2546
2846
  body_type='json'
2547
2847
  )
2548
- return TeaCore.from_map(
2549
- fc20230330_models.GetProvisionConfigResponse(),
2550
- self.call_api(params, req, runtime)
2551
- )
2848
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2849
+ return TeaCore.from_map(
2850
+ fc20230330_models.GetProvisionConfigResponse(),
2851
+ self.call_api(params, req, runtime)
2852
+ )
2853
+ else:
2854
+ return TeaCore.from_map(
2855
+ fc20230330_models.GetProvisionConfigResponse(),
2856
+ self.execute(params, req, runtime)
2857
+ )
2552
2858
 
2553
2859
  async def get_provision_config_with_options_async(
2554
2860
  self,
@@ -2584,10 +2890,16 @@ class Client(OpenApiClient):
2584
2890
  req_body_type='json',
2585
2891
  body_type='json'
2586
2892
  )
2587
- return TeaCore.from_map(
2588
- fc20230330_models.GetProvisionConfigResponse(),
2589
- await self.call_api_async(params, req, runtime)
2590
- )
2893
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2894
+ return TeaCore.from_map(
2895
+ fc20230330_models.GetProvisionConfigResponse(),
2896
+ await self.call_api_async(params, req, runtime)
2897
+ )
2898
+ else:
2899
+ return TeaCore.from_map(
2900
+ fc20230330_models.GetProvisionConfigResponse(),
2901
+ await self.execute_async(params, req, runtime)
2902
+ )
2591
2903
 
2592
2904
  def get_provision_config(
2593
2905
  self,
@@ -2647,10 +2959,16 @@ class Client(OpenApiClient):
2647
2959
  req_body_type='json',
2648
2960
  body_type='json'
2649
2961
  )
2650
- return TeaCore.from_map(
2651
- fc20230330_models.GetTriggerResponse(),
2652
- self.call_api(params, req, runtime)
2653
- )
2962
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
2963
+ return TeaCore.from_map(
2964
+ fc20230330_models.GetTriggerResponse(),
2965
+ self.call_api(params, req, runtime)
2966
+ )
2967
+ else:
2968
+ return TeaCore.from_map(
2969
+ fc20230330_models.GetTriggerResponse(),
2970
+ self.execute(params, req, runtime)
2971
+ )
2654
2972
 
2655
2973
  async def get_trigger_with_options_async(
2656
2974
  self,
@@ -2680,10 +2998,16 @@ class Client(OpenApiClient):
2680
2998
  req_body_type='json',
2681
2999
  body_type='json'
2682
3000
  )
2683
- return TeaCore.from_map(
2684
- fc20230330_models.GetTriggerResponse(),
2685
- await self.call_api_async(params, req, runtime)
2686
- )
3001
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3002
+ return TeaCore.from_map(
3003
+ fc20230330_models.GetTriggerResponse(),
3004
+ await self.call_api_async(params, req, runtime)
3005
+ )
3006
+ else:
3007
+ return TeaCore.from_map(
3008
+ fc20230330_models.GetTriggerResponse(),
3009
+ await self.execute_async(params, req, runtime)
3010
+ )
2687
3011
 
2688
3012
  def get_trigger(
2689
3013
  self,
@@ -2897,10 +3221,16 @@ class Client(OpenApiClient):
2897
3221
  req_body_type='json',
2898
3222
  body_type='json'
2899
3223
  )
2900
- return TeaCore.from_map(
2901
- fc20230330_models.ListAliasesResponse(),
2902
- self.call_api(params, req, runtime)
2903
- )
3224
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3225
+ return TeaCore.from_map(
3226
+ fc20230330_models.ListAliasesResponse(),
3227
+ self.call_api(params, req, runtime)
3228
+ )
3229
+ else:
3230
+ return TeaCore.from_map(
3231
+ fc20230330_models.ListAliasesResponse(),
3232
+ self.execute(params, req, runtime)
3233
+ )
2904
3234
 
2905
3235
  async def list_aliases_with_options_async(
2906
3236
  self,
@@ -2940,10 +3270,16 @@ class Client(OpenApiClient):
2940
3270
  req_body_type='json',
2941
3271
  body_type='json'
2942
3272
  )
2943
- return TeaCore.from_map(
2944
- fc20230330_models.ListAliasesResponse(),
2945
- await self.call_api_async(params, req, runtime)
2946
- )
3273
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3274
+ return TeaCore.from_map(
3275
+ fc20230330_models.ListAliasesResponse(),
3276
+ await self.call_api_async(params, req, runtime)
3277
+ )
3278
+ else:
3279
+ return TeaCore.from_map(
3280
+ fc20230330_models.ListAliasesResponse(),
3281
+ await self.execute_async(params, req, runtime)
3282
+ )
2947
3283
 
2948
3284
  def list_aliases(
2949
3285
  self,
@@ -3012,10 +3348,16 @@ class Client(OpenApiClient):
3012
3348
  req_body_type='json',
3013
3349
  body_type='json'
3014
3350
  )
3015
- return TeaCore.from_map(
3016
- fc20230330_models.ListAsyncInvokeConfigsResponse(),
3017
- self.call_api(params, req, runtime)
3018
- )
3351
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3352
+ return TeaCore.from_map(
3353
+ fc20230330_models.ListAsyncInvokeConfigsResponse(),
3354
+ self.call_api(params, req, runtime)
3355
+ )
3356
+ else:
3357
+ return TeaCore.from_map(
3358
+ fc20230330_models.ListAsyncInvokeConfigsResponse(),
3359
+ self.execute(params, req, runtime)
3360
+ )
3019
3361
 
3020
3362
  async def list_async_invoke_configs_with_options_async(
3021
3363
  self,
@@ -3054,10 +3396,16 @@ class Client(OpenApiClient):
3054
3396
  req_body_type='json',
3055
3397
  body_type='json'
3056
3398
  )
3057
- return TeaCore.from_map(
3058
- fc20230330_models.ListAsyncInvokeConfigsResponse(),
3059
- await self.call_api_async(params, req, runtime)
3060
- )
3399
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3400
+ return TeaCore.from_map(
3401
+ fc20230330_models.ListAsyncInvokeConfigsResponse(),
3402
+ await self.call_api_async(params, req, runtime)
3403
+ )
3404
+ else:
3405
+ return TeaCore.from_map(
3406
+ fc20230330_models.ListAsyncInvokeConfigsResponse(),
3407
+ await self.execute_async(params, req, runtime)
3408
+ )
3061
3409
 
3062
3410
  def list_async_invoke_configs(
3063
3411
  self,
@@ -3137,10 +3485,16 @@ class Client(OpenApiClient):
3137
3485
  req_body_type='json',
3138
3486
  body_type='json'
3139
3487
  )
3140
- return TeaCore.from_map(
3141
- fc20230330_models.ListAsyncTasksResponse(),
3142
- self.call_api(params, req, runtime)
3143
- )
3488
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3489
+ return TeaCore.from_map(
3490
+ fc20230330_models.ListAsyncTasksResponse(),
3491
+ self.call_api(params, req, runtime)
3492
+ )
3493
+ else:
3494
+ return TeaCore.from_map(
3495
+ fc20230330_models.ListAsyncTasksResponse(),
3496
+ self.execute(params, req, runtime)
3497
+ )
3144
3498
 
3145
3499
  async def list_async_tasks_with_options_async(
3146
3500
  self,
@@ -3192,10 +3546,16 @@ class Client(OpenApiClient):
3192
3546
  req_body_type='json',
3193
3547
  body_type='json'
3194
3548
  )
3195
- return TeaCore.from_map(
3196
- fc20230330_models.ListAsyncTasksResponse(),
3197
- await self.call_api_async(params, req, runtime)
3198
- )
3549
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3550
+ return TeaCore.from_map(
3551
+ fc20230330_models.ListAsyncTasksResponse(),
3552
+ await self.call_api_async(params, req, runtime)
3553
+ )
3554
+ else:
3555
+ return TeaCore.from_map(
3556
+ fc20230330_models.ListAsyncTasksResponse(),
3557
+ await self.execute_async(params, req, runtime)
3558
+ )
3199
3559
 
3200
3560
  def list_async_tasks(
3201
3561
  self,
@@ -3264,10 +3624,16 @@ class Client(OpenApiClient):
3264
3624
  req_body_type='json',
3265
3625
  body_type='json'
3266
3626
  )
3267
- return TeaCore.from_map(
3268
- fc20230330_models.ListConcurrencyConfigsResponse(),
3269
- self.call_api(params, req, runtime)
3270
- )
3627
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3628
+ return TeaCore.from_map(
3629
+ fc20230330_models.ListConcurrencyConfigsResponse(),
3630
+ self.call_api(params, req, runtime)
3631
+ )
3632
+ else:
3633
+ return TeaCore.from_map(
3634
+ fc20230330_models.ListConcurrencyConfigsResponse(),
3635
+ self.execute(params, req, runtime)
3636
+ )
3271
3637
 
3272
3638
  async def list_concurrency_configs_with_options_async(
3273
3639
  self,
@@ -3306,10 +3672,16 @@ class Client(OpenApiClient):
3306
3672
  req_body_type='json',
3307
3673
  body_type='json'
3308
3674
  )
3309
- return TeaCore.from_map(
3310
- fc20230330_models.ListConcurrencyConfigsResponse(),
3311
- await self.call_api_async(params, req, runtime)
3312
- )
3675
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3676
+ return TeaCore.from_map(
3677
+ fc20230330_models.ListConcurrencyConfigsResponse(),
3678
+ await self.call_api_async(params, req, runtime)
3679
+ )
3680
+ else:
3681
+ return TeaCore.from_map(
3682
+ fc20230330_models.ListConcurrencyConfigsResponse(),
3683
+ await self.execute_async(params, req, runtime)
3684
+ )
3313
3685
 
3314
3686
  def list_concurrency_configs(
3315
3687
  self,
@@ -3376,10 +3748,16 @@ class Client(OpenApiClient):
3376
3748
  req_body_type='json',
3377
3749
  body_type='json'
3378
3750
  )
3379
- return TeaCore.from_map(
3380
- fc20230330_models.ListCustomDomainsResponse(),
3381
- self.call_api(params, req, runtime)
3382
- )
3751
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3752
+ return TeaCore.from_map(
3753
+ fc20230330_models.ListCustomDomainsResponse(),
3754
+ self.call_api(params, req, runtime)
3755
+ )
3756
+ else:
3757
+ return TeaCore.from_map(
3758
+ fc20230330_models.ListCustomDomainsResponse(),
3759
+ self.execute(params, req, runtime)
3760
+ )
3383
3761
 
3384
3762
  async def list_custom_domains_with_options_async(
3385
3763
  self,
@@ -3418,10 +3796,16 @@ class Client(OpenApiClient):
3418
3796
  req_body_type='json',
3419
3797
  body_type='json'
3420
3798
  )
3421
- return TeaCore.from_map(
3422
- fc20230330_models.ListCustomDomainsResponse(),
3423
- await self.call_api_async(params, req, runtime)
3424
- )
3799
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3800
+ return TeaCore.from_map(
3801
+ fc20230330_models.ListCustomDomainsResponse(),
3802
+ await self.call_api_async(params, req, runtime)
3803
+ )
3804
+ else:
3805
+ return TeaCore.from_map(
3806
+ fc20230330_models.ListCustomDomainsResponse(),
3807
+ await self.execute_async(params, req, runtime)
3808
+ )
3425
3809
 
3426
3810
  def list_custom_domains(
3427
3811
  self,
@@ -3489,10 +3873,16 @@ class Client(OpenApiClient):
3489
3873
  req_body_type='json',
3490
3874
  body_type='json'
3491
3875
  )
3492
- return TeaCore.from_map(
3493
- fc20230330_models.ListFunctionVersionsResponse(),
3494
- self.call_api(params, req, runtime)
3495
- )
3876
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3877
+ return TeaCore.from_map(
3878
+ fc20230330_models.ListFunctionVersionsResponse(),
3879
+ self.call_api(params, req, runtime)
3880
+ )
3881
+ else:
3882
+ return TeaCore.from_map(
3883
+ fc20230330_models.ListFunctionVersionsResponse(),
3884
+ self.execute(params, req, runtime)
3885
+ )
3496
3886
 
3497
3887
  async def list_function_versions_with_options_async(
3498
3888
  self,
@@ -3532,10 +3922,16 @@ class Client(OpenApiClient):
3532
3922
  req_body_type='json',
3533
3923
  body_type='json'
3534
3924
  )
3535
- return TeaCore.from_map(
3536
- fc20230330_models.ListFunctionVersionsResponse(),
3537
- await self.call_api_async(params, req, runtime)
3538
- )
3925
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
3926
+ return TeaCore.from_map(
3927
+ fc20230330_models.ListFunctionVersionsResponse(),
3928
+ await self.call_api_async(params, req, runtime)
3929
+ )
3930
+ else:
3931
+ return TeaCore.from_map(
3932
+ fc20230330_models.ListFunctionVersionsResponse(),
3933
+ await self.execute_async(params, req, runtime)
3934
+ )
3539
3935
 
3540
3936
  def list_function_versions(
3541
3937
  self,
@@ -3569,19 +3965,23 @@ class Client(OpenApiClient):
3569
3965
 
3570
3966
  def list_functions_with_options(
3571
3967
  self,
3572
- request: fc20230330_models.ListFunctionsRequest,
3968
+ tmp_req: fc20230330_models.ListFunctionsRequest,
3573
3969
  headers: Dict[str, str],
3574
3970
  runtime: util_models.RuntimeOptions,
3575
3971
  ) -> fc20230330_models.ListFunctionsResponse:
3576
3972
  """
3577
3973
  @summary 列出函数。
3578
3974
 
3579
- @param request: ListFunctionsRequest
3975
+ @param tmp_req: ListFunctionsRequest
3580
3976
  @param headers: map
3581
3977
  @param runtime: runtime options for this request RuntimeOptions
3582
3978
  @return: ListFunctionsResponse
3583
3979
  """
3584
- UtilClient.validate_model(request)
3980
+ UtilClient.validate_model(tmp_req)
3981
+ request = fc20230330_models.ListFunctionsShrinkRequest()
3982
+ OpenApiUtilClient.convert(tmp_req, request)
3983
+ if not UtilClient.is_unset(tmp_req.tags):
3984
+ request.tags_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tags, 'tags', 'json')
3585
3985
  query = {}
3586
3986
  if not UtilClient.is_unset(request.fc_version):
3587
3987
  query['fcVersion'] = request.fc_version
@@ -3591,6 +3991,8 @@ class Client(OpenApiClient):
3591
3991
  query['nextToken'] = request.next_token
3592
3992
  if not UtilClient.is_unset(request.prefix):
3593
3993
  query['prefix'] = request.prefix
3994
+ if not UtilClient.is_unset(request.tags_shrink):
3995
+ query['tags'] = request.tags_shrink
3594
3996
  req = open_api_models.OpenApiRequest(
3595
3997
  headers=headers,
3596
3998
  query=OpenApiUtilClient.query(query)
@@ -3606,26 +4008,36 @@ class Client(OpenApiClient):
3606
4008
  req_body_type='json',
3607
4009
  body_type='json'
3608
4010
  )
3609
- return TeaCore.from_map(
3610
- fc20230330_models.ListFunctionsResponse(),
3611
- self.call_api(params, req, runtime)
3612
- )
4011
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4012
+ return TeaCore.from_map(
4013
+ fc20230330_models.ListFunctionsResponse(),
4014
+ self.call_api(params, req, runtime)
4015
+ )
4016
+ else:
4017
+ return TeaCore.from_map(
4018
+ fc20230330_models.ListFunctionsResponse(),
4019
+ self.execute(params, req, runtime)
4020
+ )
3613
4021
 
3614
4022
  async def list_functions_with_options_async(
3615
4023
  self,
3616
- request: fc20230330_models.ListFunctionsRequest,
4024
+ tmp_req: fc20230330_models.ListFunctionsRequest,
3617
4025
  headers: Dict[str, str],
3618
4026
  runtime: util_models.RuntimeOptions,
3619
4027
  ) -> fc20230330_models.ListFunctionsResponse:
3620
4028
  """
3621
4029
  @summary 列出函数。
3622
4030
 
3623
- @param request: ListFunctionsRequest
4031
+ @param tmp_req: ListFunctionsRequest
3624
4032
  @param headers: map
3625
4033
  @param runtime: runtime options for this request RuntimeOptions
3626
4034
  @return: ListFunctionsResponse
3627
4035
  """
3628
- UtilClient.validate_model(request)
4036
+ UtilClient.validate_model(tmp_req)
4037
+ request = fc20230330_models.ListFunctionsShrinkRequest()
4038
+ OpenApiUtilClient.convert(tmp_req, request)
4039
+ if not UtilClient.is_unset(tmp_req.tags):
4040
+ request.tags_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tags, 'tags', 'json')
3629
4041
  query = {}
3630
4042
  if not UtilClient.is_unset(request.fc_version):
3631
4043
  query['fcVersion'] = request.fc_version
@@ -3635,6 +4047,8 @@ class Client(OpenApiClient):
3635
4047
  query['nextToken'] = request.next_token
3636
4048
  if not UtilClient.is_unset(request.prefix):
3637
4049
  query['prefix'] = request.prefix
4050
+ if not UtilClient.is_unset(request.tags_shrink):
4051
+ query['tags'] = request.tags_shrink
3638
4052
  req = open_api_models.OpenApiRequest(
3639
4053
  headers=headers,
3640
4054
  query=OpenApiUtilClient.query(query)
@@ -3650,10 +4064,16 @@ class Client(OpenApiClient):
3650
4064
  req_body_type='json',
3651
4065
  body_type='json'
3652
4066
  )
3653
- return TeaCore.from_map(
3654
- fc20230330_models.ListFunctionsResponse(),
3655
- await self.call_api_async(params, req, runtime)
3656
- )
4067
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4068
+ return TeaCore.from_map(
4069
+ fc20230330_models.ListFunctionsResponse(),
4070
+ await self.call_api_async(params, req, runtime)
4071
+ )
4072
+ else:
4073
+ return TeaCore.from_map(
4074
+ fc20230330_models.ListFunctionsResponse(),
4075
+ await self.execute_async(params, req, runtime)
4076
+ )
3657
4077
 
3658
4078
  def list_functions(
3659
4079
  self,
@@ -3737,10 +4157,16 @@ class Client(OpenApiClient):
3737
4157
  req_body_type='json',
3738
4158
  body_type='json'
3739
4159
  )
3740
- return TeaCore.from_map(
3741
- fc20230330_models.ListInstancesResponse(),
3742
- self.call_api(params, req, runtime)
3743
- )
4160
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4161
+ return TeaCore.from_map(
4162
+ fc20230330_models.ListInstancesResponse(),
4163
+ self.call_api(params, req, runtime)
4164
+ )
4165
+ else:
4166
+ return TeaCore.from_map(
4167
+ fc20230330_models.ListInstancesResponse(),
4168
+ self.execute(params, req, runtime)
4169
+ )
3744
4170
 
3745
4171
  async def list_instances_with_options_async(
3746
4172
  self,
@@ -3796,10 +4222,16 @@ class Client(OpenApiClient):
3796
4222
  req_body_type='json',
3797
4223
  body_type='json'
3798
4224
  )
3799
- return TeaCore.from_map(
3800
- fc20230330_models.ListInstancesResponse(),
3801
- await self.call_api_async(params, req, runtime)
3802
- )
4225
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4226
+ return TeaCore.from_map(
4227
+ fc20230330_models.ListInstancesResponse(),
4228
+ await self.call_api_async(params, req, runtime)
4229
+ )
4230
+ else:
4231
+ return TeaCore.from_map(
4232
+ fc20230330_models.ListInstancesResponse(),
4233
+ await self.execute_async(params, req, runtime)
4234
+ )
3803
4235
 
3804
4236
  def list_instances(
3805
4237
  self,
@@ -3867,10 +4299,16 @@ class Client(OpenApiClient):
3867
4299
  req_body_type='json',
3868
4300
  body_type='json'
3869
4301
  )
3870
- return TeaCore.from_map(
3871
- fc20230330_models.ListLayerVersionsResponse(),
3872
- self.call_api(params, req, runtime)
3873
- )
4302
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4303
+ return TeaCore.from_map(
4304
+ fc20230330_models.ListLayerVersionsResponse(),
4305
+ self.call_api(params, req, runtime)
4306
+ )
4307
+ else:
4308
+ return TeaCore.from_map(
4309
+ fc20230330_models.ListLayerVersionsResponse(),
4310
+ self.execute(params, req, runtime)
4311
+ )
3874
4312
 
3875
4313
  async def list_layer_versions_with_options_async(
3876
4314
  self,
@@ -3908,10 +4346,16 @@ class Client(OpenApiClient):
3908
4346
  req_body_type='json',
3909
4347
  body_type='json'
3910
4348
  )
3911
- return TeaCore.from_map(
3912
- fc20230330_models.ListLayerVersionsResponse(),
3913
- await self.call_api_async(params, req, runtime)
3914
- )
4349
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4350
+ return TeaCore.from_map(
4351
+ fc20230330_models.ListLayerVersionsResponse(),
4352
+ await self.call_api_async(params, req, runtime)
4353
+ )
4354
+ else:
4355
+ return TeaCore.from_map(
4356
+ fc20230330_models.ListLayerVersionsResponse(),
4357
+ await self.execute_async(params, req, runtime)
4358
+ )
3915
4359
 
3916
4360
  def list_layer_versions(
3917
4361
  self,
@@ -3984,10 +4428,16 @@ class Client(OpenApiClient):
3984
4428
  req_body_type='json',
3985
4429
  body_type='json'
3986
4430
  )
3987
- return TeaCore.from_map(
3988
- fc20230330_models.ListLayersResponse(),
3989
- self.call_api(params, req, runtime)
3990
- )
4431
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4432
+ return TeaCore.from_map(
4433
+ fc20230330_models.ListLayersResponse(),
4434
+ self.call_api(params, req, runtime)
4435
+ )
4436
+ else:
4437
+ return TeaCore.from_map(
4438
+ fc20230330_models.ListLayersResponse(),
4439
+ self.execute(params, req, runtime)
4440
+ )
3991
4441
 
3992
4442
  async def list_layers_with_options_async(
3993
4443
  self,
@@ -4030,10 +4480,16 @@ class Client(OpenApiClient):
4030
4480
  req_body_type='json',
4031
4481
  body_type='json'
4032
4482
  )
4033
- return TeaCore.from_map(
4034
- fc20230330_models.ListLayersResponse(),
4035
- await self.call_api_async(params, req, runtime)
4036
- )
4483
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4484
+ return TeaCore.from_map(
4485
+ fc20230330_models.ListLayersResponse(),
4486
+ await self.call_api_async(params, req, runtime)
4487
+ )
4488
+ else:
4489
+ return TeaCore.from_map(
4490
+ fc20230330_models.ListLayersResponse(),
4491
+ await self.execute_async(params, req, runtime)
4492
+ )
4037
4493
 
4038
4494
  def list_layers(
4039
4495
  self,
@@ -4100,10 +4556,16 @@ class Client(OpenApiClient):
4100
4556
  req_body_type='json',
4101
4557
  body_type='json'
4102
4558
  )
4103
- return TeaCore.from_map(
4104
- fc20230330_models.ListProvisionConfigsResponse(),
4105
- self.call_api(params, req, runtime)
4106
- )
4559
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4560
+ return TeaCore.from_map(
4561
+ fc20230330_models.ListProvisionConfigsResponse(),
4562
+ self.call_api(params, req, runtime)
4563
+ )
4564
+ else:
4565
+ return TeaCore.from_map(
4566
+ fc20230330_models.ListProvisionConfigsResponse(),
4567
+ self.execute(params, req, runtime)
4568
+ )
4107
4569
 
4108
4570
  async def list_provision_configs_with_options_async(
4109
4571
  self,
@@ -4142,10 +4604,16 @@ class Client(OpenApiClient):
4142
4604
  req_body_type='json',
4143
4605
  body_type='json'
4144
4606
  )
4145
- return TeaCore.from_map(
4146
- fc20230330_models.ListProvisionConfigsResponse(),
4147
- await self.call_api_async(params, req, runtime)
4148
- )
4607
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4608
+ return TeaCore.from_map(
4609
+ fc20230330_models.ListProvisionConfigsResponse(),
4610
+ await self.call_api_async(params, req, runtime)
4611
+ )
4612
+ else:
4613
+ return TeaCore.from_map(
4614
+ fc20230330_models.ListProvisionConfigsResponse(),
4615
+ await self.execute_async(params, req, runtime)
4616
+ )
4149
4617
 
4150
4618
  def list_provision_configs(
4151
4619
  self,
@@ -4222,10 +4690,16 @@ class Client(OpenApiClient):
4222
4690
  req_body_type='json',
4223
4691
  body_type='json'
4224
4692
  )
4225
- return TeaCore.from_map(
4226
- fc20230330_models.ListTagResourcesResponse(),
4227
- self.call_api(params, req, runtime)
4228
- )
4693
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4694
+ return TeaCore.from_map(
4695
+ fc20230330_models.ListTagResourcesResponse(),
4696
+ self.call_api(params, req, runtime)
4697
+ )
4698
+ else:
4699
+ return TeaCore.from_map(
4700
+ fc20230330_models.ListTagResourcesResponse(),
4701
+ self.execute(params, req, runtime)
4702
+ )
4229
4703
 
4230
4704
  async def list_tag_resources_with_options_async(
4231
4705
  self,
@@ -4274,10 +4748,16 @@ class Client(OpenApiClient):
4274
4748
  req_body_type='json',
4275
4749
  body_type='json'
4276
4750
  )
4277
- return TeaCore.from_map(
4278
- fc20230330_models.ListTagResourcesResponse(),
4279
- await self.call_api_async(params, req, runtime)
4280
- )
4751
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4752
+ return TeaCore.from_map(
4753
+ fc20230330_models.ListTagResourcesResponse(),
4754
+ await self.call_api_async(params, req, runtime)
4755
+ )
4756
+ else:
4757
+ return TeaCore.from_map(
4758
+ fc20230330_models.ListTagResourcesResponse(),
4759
+ await self.execute_async(params, req, runtime)
4760
+ )
4281
4761
 
4282
4762
  def list_tag_resources(
4283
4763
  self,
@@ -4345,10 +4825,16 @@ class Client(OpenApiClient):
4345
4825
  req_body_type='json',
4346
4826
  body_type='json'
4347
4827
  )
4348
- return TeaCore.from_map(
4349
- fc20230330_models.ListTriggersResponse(),
4350
- self.call_api(params, req, runtime)
4351
- )
4828
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4829
+ return TeaCore.from_map(
4830
+ fc20230330_models.ListTriggersResponse(),
4831
+ self.call_api(params, req, runtime)
4832
+ )
4833
+ else:
4834
+ return TeaCore.from_map(
4835
+ fc20230330_models.ListTriggersResponse(),
4836
+ self.execute(params, req, runtime)
4837
+ )
4352
4838
 
4353
4839
  async def list_triggers_with_options_async(
4354
4840
  self,
@@ -4388,10 +4874,16 @@ class Client(OpenApiClient):
4388
4874
  req_body_type='json',
4389
4875
  body_type='json'
4390
4876
  )
4391
- return TeaCore.from_map(
4392
- fc20230330_models.ListTriggersResponse(),
4393
- await self.call_api_async(params, req, runtime)
4394
- )
4877
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4878
+ return TeaCore.from_map(
4879
+ fc20230330_models.ListTriggersResponse(),
4880
+ await self.call_api_async(params, req, runtime)
4881
+ )
4882
+ else:
4883
+ return TeaCore.from_map(
4884
+ fc20230330_models.ListTriggersResponse(),
4885
+ await self.execute_async(params, req, runtime)
4886
+ )
4395
4887
 
4396
4888
  def list_triggers(
4397
4889
  self,
@@ -4450,10 +4942,16 @@ class Client(OpenApiClient):
4450
4942
  req_body_type='json',
4451
4943
  body_type='json'
4452
4944
  )
4453
- return TeaCore.from_map(
4454
- fc20230330_models.ListVpcBindingsResponse(),
4455
- self.call_api(params, req, runtime)
4456
- )
4945
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4946
+ return TeaCore.from_map(
4947
+ fc20230330_models.ListVpcBindingsResponse(),
4948
+ self.call_api(params, req, runtime)
4949
+ )
4950
+ else:
4951
+ return TeaCore.from_map(
4952
+ fc20230330_models.ListVpcBindingsResponse(),
4953
+ self.execute(params, req, runtime)
4954
+ )
4457
4955
 
4458
4956
  async def list_vpc_bindings_with_options_async(
4459
4957
  self,
@@ -4482,10 +4980,16 @@ class Client(OpenApiClient):
4482
4980
  req_body_type='json',
4483
4981
  body_type='json'
4484
4982
  )
4485
- return TeaCore.from_map(
4486
- fc20230330_models.ListVpcBindingsResponse(),
4487
- await self.call_api_async(params, req, runtime)
4488
- )
4983
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4984
+ return TeaCore.from_map(
4985
+ fc20230330_models.ListVpcBindingsResponse(),
4986
+ await self.call_api_async(params, req, runtime)
4987
+ )
4988
+ else:
4989
+ return TeaCore.from_map(
4990
+ fc20230330_models.ListVpcBindingsResponse(),
4991
+ await self.execute_async(params, req, runtime)
4992
+ )
4489
4993
 
4490
4994
  def list_vpc_bindings(
4491
4995
  self,
@@ -4544,10 +5048,16 @@ class Client(OpenApiClient):
4544
5048
  req_body_type='json',
4545
5049
  body_type='json'
4546
5050
  )
4547
- return TeaCore.from_map(
4548
- fc20230330_models.PublishFunctionVersionResponse(),
4549
- self.call_api(params, req, runtime)
4550
- )
5051
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5052
+ return TeaCore.from_map(
5053
+ fc20230330_models.PublishFunctionVersionResponse(),
5054
+ self.call_api(params, req, runtime)
5055
+ )
5056
+ else:
5057
+ return TeaCore.from_map(
5058
+ fc20230330_models.PublishFunctionVersionResponse(),
5059
+ self.execute(params, req, runtime)
5060
+ )
4551
5061
 
4552
5062
  async def publish_function_version_with_options_async(
4553
5063
  self,
@@ -4580,10 +5090,16 @@ class Client(OpenApiClient):
4580
5090
  req_body_type='json',
4581
5091
  body_type='json'
4582
5092
  )
4583
- return TeaCore.from_map(
4584
- fc20230330_models.PublishFunctionVersionResponse(),
4585
- await self.call_api_async(params, req, runtime)
4586
- )
5093
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5094
+ return TeaCore.from_map(
5095
+ fc20230330_models.PublishFunctionVersionResponse(),
5096
+ await self.call_api_async(params, req, runtime)
5097
+ )
5098
+ else:
5099
+ return TeaCore.from_map(
5100
+ fc20230330_models.PublishFunctionVersionResponse(),
5101
+ await self.execute_async(params, req, runtime)
5102
+ )
4587
5103
 
4588
5104
  def publish_function_version(
4589
5105
  self,
@@ -4650,10 +5166,16 @@ class Client(OpenApiClient):
4650
5166
  req_body_type='json',
4651
5167
  body_type='json'
4652
5168
  )
4653
- return TeaCore.from_map(
4654
- fc20230330_models.PutAsyncInvokeConfigResponse(),
4655
- self.call_api(params, req, runtime)
4656
- )
5169
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5170
+ return TeaCore.from_map(
5171
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5172
+ self.call_api(params, req, runtime)
5173
+ )
5174
+ else:
5175
+ return TeaCore.from_map(
5176
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5177
+ self.execute(params, req, runtime)
5178
+ )
4657
5179
 
4658
5180
  async def put_async_invoke_config_with_options_async(
4659
5181
  self,
@@ -4690,10 +5212,16 @@ class Client(OpenApiClient):
4690
5212
  req_body_type='json',
4691
5213
  body_type='json'
4692
5214
  )
4693
- return TeaCore.from_map(
4694
- fc20230330_models.PutAsyncInvokeConfigResponse(),
4695
- await self.call_api_async(params, req, runtime)
4696
- )
5215
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5216
+ return TeaCore.from_map(
5217
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5218
+ await self.call_api_async(params, req, runtime)
5219
+ )
5220
+ else:
5221
+ return TeaCore.from_map(
5222
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5223
+ await self.execute_async(params, req, runtime)
5224
+ )
4697
5225
 
4698
5226
  def put_async_invoke_config(
4699
5227
  self,
@@ -4756,10 +5284,16 @@ class Client(OpenApiClient):
4756
5284
  req_body_type='json',
4757
5285
  body_type='json'
4758
5286
  )
4759
- return TeaCore.from_map(
4760
- fc20230330_models.PutConcurrencyConfigResponse(),
4761
- self.call_api(params, req, runtime)
4762
- )
5287
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5288
+ return TeaCore.from_map(
5289
+ fc20230330_models.PutConcurrencyConfigResponse(),
5290
+ self.call_api(params, req, runtime)
5291
+ )
5292
+ else:
5293
+ return TeaCore.from_map(
5294
+ fc20230330_models.PutConcurrencyConfigResponse(),
5295
+ self.execute(params, req, runtime)
5296
+ )
4763
5297
 
4764
5298
  async def put_concurrency_config_with_options_async(
4765
5299
  self,
@@ -4792,10 +5326,16 @@ class Client(OpenApiClient):
4792
5326
  req_body_type='json',
4793
5327
  body_type='json'
4794
5328
  )
4795
- return TeaCore.from_map(
4796
- fc20230330_models.PutConcurrencyConfigResponse(),
4797
- await self.call_api_async(params, req, runtime)
4798
- )
5329
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5330
+ return TeaCore.from_map(
5331
+ fc20230330_models.PutConcurrencyConfigResponse(),
5332
+ await self.call_api_async(params, req, runtime)
5333
+ )
5334
+ else:
5335
+ return TeaCore.from_map(
5336
+ fc20230330_models.PutConcurrencyConfigResponse(),
5337
+ await self.execute_async(params, req, runtime)
5338
+ )
4799
5339
 
4800
5340
  def put_concurrency_config(
4801
5341
  self,
@@ -4863,10 +5403,16 @@ class Client(OpenApiClient):
4863
5403
  req_body_type='json',
4864
5404
  body_type='none'
4865
5405
  )
4866
- return TeaCore.from_map(
4867
- fc20230330_models.PutLayerACLResponse(),
4868
- self.call_api(params, req, runtime)
4869
- )
5406
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5407
+ return TeaCore.from_map(
5408
+ fc20230330_models.PutLayerACLResponse(),
5409
+ self.call_api(params, req, runtime)
5410
+ )
5411
+ else:
5412
+ return TeaCore.from_map(
5413
+ fc20230330_models.PutLayerACLResponse(),
5414
+ self.execute(params, req, runtime)
5415
+ )
4870
5416
 
4871
5417
  async def put_layer_aclwith_options_async(
4872
5418
  self,
@@ -4904,10 +5450,16 @@ class Client(OpenApiClient):
4904
5450
  req_body_type='json',
4905
5451
  body_type='none'
4906
5452
  )
4907
- return TeaCore.from_map(
4908
- fc20230330_models.PutLayerACLResponse(),
4909
- await self.call_api_async(params, req, runtime)
4910
- )
5453
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5454
+ return TeaCore.from_map(
5455
+ fc20230330_models.PutLayerACLResponse(),
5456
+ await self.call_api_async(params, req, runtime)
5457
+ )
5458
+ else:
5459
+ return TeaCore.from_map(
5460
+ fc20230330_models.PutLayerACLResponse(),
5461
+ await self.execute_async(params, req, runtime)
5462
+ )
4911
5463
 
4912
5464
  def put_layer_acl(
4913
5465
  self,
@@ -4974,10 +5526,16 @@ class Client(OpenApiClient):
4974
5526
  req_body_type='json',
4975
5527
  body_type='json'
4976
5528
  )
4977
- return TeaCore.from_map(
4978
- fc20230330_models.PutProvisionConfigResponse(),
4979
- self.call_api(params, req, runtime)
4980
- )
5529
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5530
+ return TeaCore.from_map(
5531
+ fc20230330_models.PutProvisionConfigResponse(),
5532
+ self.call_api(params, req, runtime)
5533
+ )
5534
+ else:
5535
+ return TeaCore.from_map(
5536
+ fc20230330_models.PutProvisionConfigResponse(),
5537
+ self.execute(params, req, runtime)
5538
+ )
4981
5539
 
4982
5540
  async def put_provision_config_with_options_async(
4983
5541
  self,
@@ -5014,10 +5572,16 @@ class Client(OpenApiClient):
5014
5572
  req_body_type='json',
5015
5573
  body_type='json'
5016
5574
  )
5017
- return TeaCore.from_map(
5018
- fc20230330_models.PutProvisionConfigResponse(),
5019
- await self.call_api_async(params, req, runtime)
5020
- )
5575
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5576
+ return TeaCore.from_map(
5577
+ fc20230330_models.PutProvisionConfigResponse(),
5578
+ await self.call_api_async(params, req, runtime)
5579
+ )
5580
+ else:
5581
+ return TeaCore.from_map(
5582
+ fc20230330_models.PutProvisionConfigResponse(),
5583
+ await self.execute_async(params, req, runtime)
5584
+ )
5021
5585
 
5022
5586
  def put_provision_config(
5023
5587
  self,
@@ -5084,10 +5648,16 @@ class Client(OpenApiClient):
5084
5648
  req_body_type='json',
5085
5649
  body_type='none'
5086
5650
  )
5087
- return TeaCore.from_map(
5088
- fc20230330_models.StopAsyncTaskResponse(),
5089
- self.call_api(params, req, runtime)
5090
- )
5651
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5652
+ return TeaCore.from_map(
5653
+ fc20230330_models.StopAsyncTaskResponse(),
5654
+ self.call_api(params, req, runtime)
5655
+ )
5656
+ else:
5657
+ return TeaCore.from_map(
5658
+ fc20230330_models.StopAsyncTaskResponse(),
5659
+ self.execute(params, req, runtime)
5660
+ )
5091
5661
 
5092
5662
  async def stop_async_task_with_options_async(
5093
5663
  self,
@@ -5124,10 +5694,16 @@ class Client(OpenApiClient):
5124
5694
  req_body_type='json',
5125
5695
  body_type='none'
5126
5696
  )
5127
- return TeaCore.from_map(
5128
- fc20230330_models.StopAsyncTaskResponse(),
5129
- await self.call_api_async(params, req, runtime)
5130
- )
5697
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5698
+ return TeaCore.from_map(
5699
+ fc20230330_models.StopAsyncTaskResponse(),
5700
+ await self.call_api_async(params, req, runtime)
5701
+ )
5702
+ else:
5703
+ return TeaCore.from_map(
5704
+ fc20230330_models.StopAsyncTaskResponse(),
5705
+ await self.execute_async(params, req, runtime)
5706
+ )
5131
5707
 
5132
5708
  def stop_async_task(
5133
5709
  self,
@@ -5193,10 +5769,16 @@ class Client(OpenApiClient):
5193
5769
  req_body_type='json',
5194
5770
  body_type='none'
5195
5771
  )
5196
- return TeaCore.from_map(
5197
- fc20230330_models.TagResourcesResponse(),
5198
- self.call_api(params, req, runtime)
5199
- )
5772
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5773
+ return TeaCore.from_map(
5774
+ fc20230330_models.TagResourcesResponse(),
5775
+ self.call_api(params, req, runtime)
5776
+ )
5777
+ else:
5778
+ return TeaCore.from_map(
5779
+ fc20230330_models.TagResourcesResponse(),
5780
+ self.execute(params, req, runtime)
5781
+ )
5200
5782
 
5201
5783
  async def tag_resources_with_options_async(
5202
5784
  self,
@@ -5230,10 +5812,16 @@ class Client(OpenApiClient):
5230
5812
  req_body_type='json',
5231
5813
  body_type='none'
5232
5814
  )
5233
- return TeaCore.from_map(
5234
- fc20230330_models.TagResourcesResponse(),
5235
- await self.call_api_async(params, req, runtime)
5236
- )
5815
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5816
+ return TeaCore.from_map(
5817
+ fc20230330_models.TagResourcesResponse(),
5818
+ await self.call_api_async(params, req, runtime)
5819
+ )
5820
+ else:
5821
+ return TeaCore.from_map(
5822
+ fc20230330_models.TagResourcesResponse(),
5823
+ await self.execute_async(params, req, runtime)
5824
+ )
5237
5825
 
5238
5826
  def tag_resources(
5239
5827
  self,
@@ -5312,10 +5900,16 @@ class Client(OpenApiClient):
5312
5900
  req_body_type='json',
5313
5901
  body_type='none'
5314
5902
  )
5315
- return TeaCore.from_map(
5316
- fc20230330_models.UntagResourcesResponse(),
5317
- self.call_api(params, req, runtime)
5318
- )
5903
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5904
+ return TeaCore.from_map(
5905
+ fc20230330_models.UntagResourcesResponse(),
5906
+ self.call_api(params, req, runtime)
5907
+ )
5908
+ else:
5909
+ return TeaCore.from_map(
5910
+ fc20230330_models.UntagResourcesResponse(),
5911
+ self.execute(params, req, runtime)
5912
+ )
5319
5913
 
5320
5914
  async def untag_resources_with_options_async(
5321
5915
  self,
@@ -5362,10 +5956,16 @@ class Client(OpenApiClient):
5362
5956
  req_body_type='json',
5363
5957
  body_type='none'
5364
5958
  )
5365
- return TeaCore.from_map(
5366
- fc20230330_models.UntagResourcesResponse(),
5367
- await self.call_api_async(params, req, runtime)
5368
- )
5959
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5960
+ return TeaCore.from_map(
5961
+ fc20230330_models.UntagResourcesResponse(),
5962
+ await self.call_api_async(params, req, runtime)
5963
+ )
5964
+ else:
5965
+ return TeaCore.from_map(
5966
+ fc20230330_models.UntagResourcesResponse(),
5967
+ await self.execute_async(params, req, runtime)
5968
+ )
5369
5969
 
5370
5970
  def untag_resources(
5371
5971
  self,
@@ -5427,10 +6027,16 @@ class Client(OpenApiClient):
5427
6027
  req_body_type='json',
5428
6028
  body_type='json'
5429
6029
  )
5430
- return TeaCore.from_map(
5431
- fc20230330_models.UpdateAliasResponse(),
5432
- self.call_api(params, req, runtime)
5433
- )
6030
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6031
+ return TeaCore.from_map(
6032
+ fc20230330_models.UpdateAliasResponse(),
6033
+ self.call_api(params, req, runtime)
6034
+ )
6035
+ else:
6036
+ return TeaCore.from_map(
6037
+ fc20230330_models.UpdateAliasResponse(),
6038
+ self.execute(params, req, runtime)
6039
+ )
5434
6040
 
5435
6041
  async def update_alias_with_options_async(
5436
6042
  self,
@@ -5464,10 +6070,16 @@ class Client(OpenApiClient):
5464
6070
  req_body_type='json',
5465
6071
  body_type='json'
5466
6072
  )
5467
- return TeaCore.from_map(
5468
- fc20230330_models.UpdateAliasResponse(),
5469
- await self.call_api_async(params, req, runtime)
5470
- )
6073
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6074
+ return TeaCore.from_map(
6075
+ fc20230330_models.UpdateAliasResponse(),
6076
+ await self.call_api_async(params, req, runtime)
6077
+ )
6078
+ else:
6079
+ return TeaCore.from_map(
6080
+ fc20230330_models.UpdateAliasResponse(),
6081
+ await self.execute_async(params, req, runtime)
6082
+ )
5471
6083
 
5472
6084
  def update_alias(
5473
6085
  self,
@@ -5532,10 +6144,16 @@ class Client(OpenApiClient):
5532
6144
  req_body_type='json',
5533
6145
  body_type='json'
5534
6146
  )
5535
- return TeaCore.from_map(
5536
- fc20230330_models.UpdateCustomDomainResponse(),
5537
- self.call_api(params, req, runtime)
5538
- )
6147
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6148
+ return TeaCore.from_map(
6149
+ fc20230330_models.UpdateCustomDomainResponse(),
6150
+ self.call_api(params, req, runtime)
6151
+ )
6152
+ else:
6153
+ return TeaCore.from_map(
6154
+ fc20230330_models.UpdateCustomDomainResponse(),
6155
+ self.execute(params, req, runtime)
6156
+ )
5539
6157
 
5540
6158
  async def update_custom_domain_with_options_async(
5541
6159
  self,
@@ -5568,10 +6186,16 @@ class Client(OpenApiClient):
5568
6186
  req_body_type='json',
5569
6187
  body_type='json'
5570
6188
  )
5571
- return TeaCore.from_map(
5572
- fc20230330_models.UpdateCustomDomainResponse(),
5573
- await self.call_api_async(params, req, runtime)
5574
- )
6189
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6190
+ return TeaCore.from_map(
6191
+ fc20230330_models.UpdateCustomDomainResponse(),
6192
+ await self.call_api_async(params, req, runtime)
6193
+ )
6194
+ else:
6195
+ return TeaCore.from_map(
6196
+ fc20230330_models.UpdateCustomDomainResponse(),
6197
+ await self.execute_async(params, req, runtime)
6198
+ )
5575
6199
 
5576
6200
  def update_custom_domain(
5577
6201
  self,
@@ -5634,10 +6258,16 @@ class Client(OpenApiClient):
5634
6258
  req_body_type='json',
5635
6259
  body_type='json'
5636
6260
  )
5637
- return TeaCore.from_map(
5638
- fc20230330_models.UpdateFunctionResponse(),
5639
- self.call_api(params, req, runtime)
5640
- )
6261
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6262
+ return TeaCore.from_map(
6263
+ fc20230330_models.UpdateFunctionResponse(),
6264
+ self.call_api(params, req, runtime)
6265
+ )
6266
+ else:
6267
+ return TeaCore.from_map(
6268
+ fc20230330_models.UpdateFunctionResponse(),
6269
+ self.execute(params, req, runtime)
6270
+ )
5641
6271
 
5642
6272
  async def update_function_with_options_async(
5643
6273
  self,
@@ -5670,10 +6300,16 @@ class Client(OpenApiClient):
5670
6300
  req_body_type='json',
5671
6301
  body_type='json'
5672
6302
  )
5673
- return TeaCore.from_map(
5674
- fc20230330_models.UpdateFunctionResponse(),
5675
- await self.call_api_async(params, req, runtime)
5676
- )
6303
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6304
+ return TeaCore.from_map(
6305
+ fc20230330_models.UpdateFunctionResponse(),
6306
+ await self.call_api_async(params, req, runtime)
6307
+ )
6308
+ else:
6309
+ return TeaCore.from_map(
6310
+ fc20230330_models.UpdateFunctionResponse(),
6311
+ await self.execute_async(params, req, runtime)
6312
+ )
5677
6313
 
5678
6314
  def update_function(
5679
6315
  self,
@@ -5737,10 +6373,16 @@ class Client(OpenApiClient):
5737
6373
  req_body_type='json',
5738
6374
  body_type='json'
5739
6375
  )
5740
- return TeaCore.from_map(
5741
- fc20230330_models.UpdateTriggerResponse(),
5742
- self.call_api(params, req, runtime)
5743
- )
6376
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6377
+ return TeaCore.from_map(
6378
+ fc20230330_models.UpdateTriggerResponse(),
6379
+ self.call_api(params, req, runtime)
6380
+ )
6381
+ else:
6382
+ return TeaCore.from_map(
6383
+ fc20230330_models.UpdateTriggerResponse(),
6384
+ self.execute(params, req, runtime)
6385
+ )
5744
6386
 
5745
6387
  async def update_trigger_with_options_async(
5746
6388
  self,
@@ -5774,10 +6416,16 @@ class Client(OpenApiClient):
5774
6416
  req_body_type='json',
5775
6417
  body_type='json'
5776
6418
  )
5777
- return TeaCore.from_map(
5778
- fc20230330_models.UpdateTriggerResponse(),
5779
- await self.call_api_async(params, req, runtime)
5780
- )
6419
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6420
+ return TeaCore.from_map(
6421
+ fc20230330_models.UpdateTriggerResponse(),
6422
+ await self.call_api_async(params, req, runtime)
6423
+ )
6424
+ else:
6425
+ return TeaCore.from_map(
6426
+ fc20230330_models.UpdateTriggerResponse(),
6427
+ await self.execute_async(params, req, runtime)
6428
+ )
5781
6429
 
5782
6430
  def update_trigger(
5783
6431
  self,