alibabacloud-fc20230330 4.1.5__py3-none-any.whl → 4.1.7__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 +1102 -430
  3. alibabacloud_fc20230330/models.py +334 -0
  4. {alibabacloud_fc20230330-4.1.5.dist-info → alibabacloud_fc20230330-4.1.7.dist-info}/METADATA +1 -1
  5. alibabacloud_fc20230330-4.1.7.dist-info/RECORD +8 -0
  6. alibabacloud_fc20230330-4.1.5.dist-info/RECORD +0 -8
  7. {alibabacloud_fc20230330-4.1.5.dist-info → alibabacloud_fc20230330-4.1.7.dist-info}/LICENSE +0 -0
  8. {alibabacloud_fc20230330-4.1.5.dist-info → alibabacloud_fc20230330-4.1.7.dist-info}/WHEEL +0 -0
  9. {alibabacloud_fc20230330-4.1.5.dist-info → alibabacloud_fc20230330-4.1.7.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,
@@ -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,
@@ -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,
@@ -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,
@@ -3606,10 +4002,16 @@ class Client(OpenApiClient):
3606
4002
  req_body_type='json',
3607
4003
  body_type='json'
3608
4004
  )
3609
- return TeaCore.from_map(
3610
- fc20230330_models.ListFunctionsResponse(),
3611
- self.call_api(params, req, runtime)
3612
- )
4005
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4006
+ return TeaCore.from_map(
4007
+ fc20230330_models.ListFunctionsResponse(),
4008
+ self.call_api(params, req, runtime)
4009
+ )
4010
+ else:
4011
+ return TeaCore.from_map(
4012
+ fc20230330_models.ListFunctionsResponse(),
4013
+ self.execute(params, req, runtime)
4014
+ )
3613
4015
 
3614
4016
  async def list_functions_with_options_async(
3615
4017
  self,
@@ -3650,10 +4052,16 @@ class Client(OpenApiClient):
3650
4052
  req_body_type='json',
3651
4053
  body_type='json'
3652
4054
  )
3653
- return TeaCore.from_map(
3654
- fc20230330_models.ListFunctionsResponse(),
3655
- await self.call_api_async(params, req, runtime)
3656
- )
4055
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4056
+ return TeaCore.from_map(
4057
+ fc20230330_models.ListFunctionsResponse(),
4058
+ await self.call_api_async(params, req, runtime)
4059
+ )
4060
+ else:
4061
+ return TeaCore.from_map(
4062
+ fc20230330_models.ListFunctionsResponse(),
4063
+ await self.execute_async(params, req, runtime)
4064
+ )
3657
4065
 
3658
4066
  def list_functions(
3659
4067
  self,
@@ -3686,22 +4094,40 @@ class Client(OpenApiClient):
3686
4094
  def list_instances_with_options(
3687
4095
  self,
3688
4096
  function_name: str,
3689
- request: fc20230330_models.ListInstancesRequest,
4097
+ tmp_req: fc20230330_models.ListInstancesRequest,
3690
4098
  headers: Dict[str, str],
3691
4099
  runtime: util_models.RuntimeOptions,
3692
4100
  ) -> fc20230330_models.ListInstancesResponse:
3693
4101
  """
3694
4102
  @summary Queries a list of function instances.
3695
4103
 
3696
- @param request: ListInstancesRequest
4104
+ @param tmp_req: ListInstancesRequest
3697
4105
  @param headers: map
3698
4106
  @param runtime: runtime options for this request RuntimeOptions
3699
4107
  @return: ListInstancesResponse
3700
4108
  """
3701
- UtilClient.validate_model(request)
4109
+ UtilClient.validate_model(tmp_req)
4110
+ request = fc20230330_models.ListInstancesShrinkRequest()
4111
+ OpenApiUtilClient.convert(tmp_req, request)
4112
+ if not UtilClient.is_unset(tmp_req.instance_ids):
4113
+ request.instance_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.instance_ids, 'instanceIds', 'json')
4114
+ if not UtilClient.is_unset(tmp_req.instance_status):
4115
+ request.instance_status_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.instance_status, 'instanceStatus', 'json')
3702
4116
  query = {}
4117
+ if not UtilClient.is_unset(request.end_time_ms):
4118
+ query['endTimeMs'] = request.end_time_ms
4119
+ if not UtilClient.is_unset(request.instance_ids_shrink):
4120
+ query['instanceIds'] = request.instance_ids_shrink
4121
+ if not UtilClient.is_unset(request.instance_status_shrink):
4122
+ query['instanceStatus'] = request.instance_status_shrink
4123
+ if not UtilClient.is_unset(request.limit):
4124
+ query['limit'] = request.limit
3703
4125
  if not UtilClient.is_unset(request.qualifier):
3704
4126
  query['qualifier'] = request.qualifier
4127
+ if not UtilClient.is_unset(request.start_key):
4128
+ query['startKey'] = request.start_key
4129
+ if not UtilClient.is_unset(request.start_time_ms):
4130
+ query['startTimeMs'] = request.start_time_ms
3705
4131
  if not UtilClient.is_unset(request.with_all_active):
3706
4132
  query['withAllActive'] = request.with_all_active
3707
4133
  req = open_api_models.OpenApiRequest(
@@ -3719,30 +4145,54 @@ class Client(OpenApiClient):
3719
4145
  req_body_type='json',
3720
4146
  body_type='json'
3721
4147
  )
3722
- return TeaCore.from_map(
3723
- fc20230330_models.ListInstancesResponse(),
3724
- self.call_api(params, req, runtime)
3725
- )
4148
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4149
+ return TeaCore.from_map(
4150
+ fc20230330_models.ListInstancesResponse(),
4151
+ self.call_api(params, req, runtime)
4152
+ )
4153
+ else:
4154
+ return TeaCore.from_map(
4155
+ fc20230330_models.ListInstancesResponse(),
4156
+ self.execute(params, req, runtime)
4157
+ )
3726
4158
 
3727
4159
  async def list_instances_with_options_async(
3728
4160
  self,
3729
4161
  function_name: str,
3730
- request: fc20230330_models.ListInstancesRequest,
4162
+ tmp_req: fc20230330_models.ListInstancesRequest,
3731
4163
  headers: Dict[str, str],
3732
4164
  runtime: util_models.RuntimeOptions,
3733
4165
  ) -> fc20230330_models.ListInstancesResponse:
3734
4166
  """
3735
4167
  @summary Queries a list of function instances.
3736
4168
 
3737
- @param request: ListInstancesRequest
4169
+ @param tmp_req: ListInstancesRequest
3738
4170
  @param headers: map
3739
4171
  @param runtime: runtime options for this request RuntimeOptions
3740
4172
  @return: ListInstancesResponse
3741
4173
  """
3742
- UtilClient.validate_model(request)
4174
+ UtilClient.validate_model(tmp_req)
4175
+ request = fc20230330_models.ListInstancesShrinkRequest()
4176
+ OpenApiUtilClient.convert(tmp_req, request)
4177
+ if not UtilClient.is_unset(tmp_req.instance_ids):
4178
+ request.instance_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.instance_ids, 'instanceIds', 'json')
4179
+ if not UtilClient.is_unset(tmp_req.instance_status):
4180
+ request.instance_status_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.instance_status, 'instanceStatus', 'json')
3743
4181
  query = {}
4182
+ if not UtilClient.is_unset(request.end_time_ms):
4183
+ query['endTimeMs'] = request.end_time_ms
4184
+ if not UtilClient.is_unset(request.instance_ids_shrink):
4185
+ query['instanceIds'] = request.instance_ids_shrink
4186
+ if not UtilClient.is_unset(request.instance_status_shrink):
4187
+ query['instanceStatus'] = request.instance_status_shrink
4188
+ if not UtilClient.is_unset(request.limit):
4189
+ query['limit'] = request.limit
3744
4190
  if not UtilClient.is_unset(request.qualifier):
3745
4191
  query['qualifier'] = request.qualifier
4192
+ if not UtilClient.is_unset(request.start_key):
4193
+ query['startKey'] = request.start_key
4194
+ if not UtilClient.is_unset(request.start_time_ms):
4195
+ query['startTimeMs'] = request.start_time_ms
3746
4196
  if not UtilClient.is_unset(request.with_all_active):
3747
4197
  query['withAllActive'] = request.with_all_active
3748
4198
  req = open_api_models.OpenApiRequest(
@@ -3760,10 +4210,16 @@ class Client(OpenApiClient):
3760
4210
  req_body_type='json',
3761
4211
  body_type='json'
3762
4212
  )
3763
- return TeaCore.from_map(
3764
- fc20230330_models.ListInstancesResponse(),
3765
- await self.call_api_async(params, req, runtime)
3766
- )
4213
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4214
+ return TeaCore.from_map(
4215
+ fc20230330_models.ListInstancesResponse(),
4216
+ await self.call_api_async(params, req, runtime)
4217
+ )
4218
+ else:
4219
+ return TeaCore.from_map(
4220
+ fc20230330_models.ListInstancesResponse(),
4221
+ await self.execute_async(params, req, runtime)
4222
+ )
3767
4223
 
3768
4224
  def list_instances(
3769
4225
  self,
@@ -3831,10 +4287,16 @@ class Client(OpenApiClient):
3831
4287
  req_body_type='json',
3832
4288
  body_type='json'
3833
4289
  )
3834
- return TeaCore.from_map(
3835
- fc20230330_models.ListLayerVersionsResponse(),
3836
- self.call_api(params, req, runtime)
3837
- )
4290
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4291
+ return TeaCore.from_map(
4292
+ fc20230330_models.ListLayerVersionsResponse(),
4293
+ self.call_api(params, req, runtime)
4294
+ )
4295
+ else:
4296
+ return TeaCore.from_map(
4297
+ fc20230330_models.ListLayerVersionsResponse(),
4298
+ self.execute(params, req, runtime)
4299
+ )
3838
4300
 
3839
4301
  async def list_layer_versions_with_options_async(
3840
4302
  self,
@@ -3872,10 +4334,16 @@ class Client(OpenApiClient):
3872
4334
  req_body_type='json',
3873
4335
  body_type='json'
3874
4336
  )
3875
- return TeaCore.from_map(
3876
- fc20230330_models.ListLayerVersionsResponse(),
3877
- await self.call_api_async(params, req, runtime)
3878
- )
4337
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4338
+ return TeaCore.from_map(
4339
+ fc20230330_models.ListLayerVersionsResponse(),
4340
+ await self.call_api_async(params, req, runtime)
4341
+ )
4342
+ else:
4343
+ return TeaCore.from_map(
4344
+ fc20230330_models.ListLayerVersionsResponse(),
4345
+ await self.execute_async(params, req, runtime)
4346
+ )
3879
4347
 
3880
4348
  def list_layer_versions(
3881
4349
  self,
@@ -3948,10 +4416,16 @@ class Client(OpenApiClient):
3948
4416
  req_body_type='json',
3949
4417
  body_type='json'
3950
4418
  )
3951
- return TeaCore.from_map(
3952
- fc20230330_models.ListLayersResponse(),
3953
- self.call_api(params, req, runtime)
3954
- )
4419
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4420
+ return TeaCore.from_map(
4421
+ fc20230330_models.ListLayersResponse(),
4422
+ self.call_api(params, req, runtime)
4423
+ )
4424
+ else:
4425
+ return TeaCore.from_map(
4426
+ fc20230330_models.ListLayersResponse(),
4427
+ self.execute(params, req, runtime)
4428
+ )
3955
4429
 
3956
4430
  async def list_layers_with_options_async(
3957
4431
  self,
@@ -3994,10 +4468,16 @@ class Client(OpenApiClient):
3994
4468
  req_body_type='json',
3995
4469
  body_type='json'
3996
4470
  )
3997
- return TeaCore.from_map(
3998
- fc20230330_models.ListLayersResponse(),
3999
- await self.call_api_async(params, req, runtime)
4000
- )
4471
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4472
+ return TeaCore.from_map(
4473
+ fc20230330_models.ListLayersResponse(),
4474
+ await self.call_api_async(params, req, runtime)
4475
+ )
4476
+ else:
4477
+ return TeaCore.from_map(
4478
+ fc20230330_models.ListLayersResponse(),
4479
+ await self.execute_async(params, req, runtime)
4480
+ )
4001
4481
 
4002
4482
  def list_layers(
4003
4483
  self,
@@ -4064,10 +4544,16 @@ class Client(OpenApiClient):
4064
4544
  req_body_type='json',
4065
4545
  body_type='json'
4066
4546
  )
4067
- return TeaCore.from_map(
4068
- fc20230330_models.ListProvisionConfigsResponse(),
4069
- self.call_api(params, req, runtime)
4070
- )
4547
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4548
+ return TeaCore.from_map(
4549
+ fc20230330_models.ListProvisionConfigsResponse(),
4550
+ self.call_api(params, req, runtime)
4551
+ )
4552
+ else:
4553
+ return TeaCore.from_map(
4554
+ fc20230330_models.ListProvisionConfigsResponse(),
4555
+ self.execute(params, req, runtime)
4556
+ )
4071
4557
 
4072
4558
  async def list_provision_configs_with_options_async(
4073
4559
  self,
@@ -4106,10 +4592,16 @@ class Client(OpenApiClient):
4106
4592
  req_body_type='json',
4107
4593
  body_type='json'
4108
4594
  )
4109
- return TeaCore.from_map(
4110
- fc20230330_models.ListProvisionConfigsResponse(),
4111
- await self.call_api_async(params, req, runtime)
4112
- )
4595
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4596
+ return TeaCore.from_map(
4597
+ fc20230330_models.ListProvisionConfigsResponse(),
4598
+ await self.call_api_async(params, req, runtime)
4599
+ )
4600
+ else:
4601
+ return TeaCore.from_map(
4602
+ fc20230330_models.ListProvisionConfigsResponse(),
4603
+ await self.execute_async(params, req, runtime)
4604
+ )
4113
4605
 
4114
4606
  def list_provision_configs(
4115
4607
  self,
@@ -4186,10 +4678,16 @@ class Client(OpenApiClient):
4186
4678
  req_body_type='json',
4187
4679
  body_type='json'
4188
4680
  )
4189
- return TeaCore.from_map(
4190
- fc20230330_models.ListTagResourcesResponse(),
4191
- self.call_api(params, req, runtime)
4192
- )
4681
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4682
+ return TeaCore.from_map(
4683
+ fc20230330_models.ListTagResourcesResponse(),
4684
+ self.call_api(params, req, runtime)
4685
+ )
4686
+ else:
4687
+ return TeaCore.from_map(
4688
+ fc20230330_models.ListTagResourcesResponse(),
4689
+ self.execute(params, req, runtime)
4690
+ )
4193
4691
 
4194
4692
  async def list_tag_resources_with_options_async(
4195
4693
  self,
@@ -4238,10 +4736,16 @@ class Client(OpenApiClient):
4238
4736
  req_body_type='json',
4239
4737
  body_type='json'
4240
4738
  )
4241
- return TeaCore.from_map(
4242
- fc20230330_models.ListTagResourcesResponse(),
4243
- await self.call_api_async(params, req, runtime)
4244
- )
4739
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4740
+ return TeaCore.from_map(
4741
+ fc20230330_models.ListTagResourcesResponse(),
4742
+ await self.call_api_async(params, req, runtime)
4743
+ )
4744
+ else:
4745
+ return TeaCore.from_map(
4746
+ fc20230330_models.ListTagResourcesResponse(),
4747
+ await self.execute_async(params, req, runtime)
4748
+ )
4245
4749
 
4246
4750
  def list_tag_resources(
4247
4751
  self,
@@ -4309,10 +4813,16 @@ class Client(OpenApiClient):
4309
4813
  req_body_type='json',
4310
4814
  body_type='json'
4311
4815
  )
4312
- return TeaCore.from_map(
4313
- fc20230330_models.ListTriggersResponse(),
4314
- self.call_api(params, req, runtime)
4315
- )
4816
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4817
+ return TeaCore.from_map(
4818
+ fc20230330_models.ListTriggersResponse(),
4819
+ self.call_api(params, req, runtime)
4820
+ )
4821
+ else:
4822
+ return TeaCore.from_map(
4823
+ fc20230330_models.ListTriggersResponse(),
4824
+ self.execute(params, req, runtime)
4825
+ )
4316
4826
 
4317
4827
  async def list_triggers_with_options_async(
4318
4828
  self,
@@ -4352,10 +4862,16 @@ class Client(OpenApiClient):
4352
4862
  req_body_type='json',
4353
4863
  body_type='json'
4354
4864
  )
4355
- return TeaCore.from_map(
4356
- fc20230330_models.ListTriggersResponse(),
4357
- await self.call_api_async(params, req, runtime)
4358
- )
4865
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4866
+ return TeaCore.from_map(
4867
+ fc20230330_models.ListTriggersResponse(),
4868
+ await self.call_api_async(params, req, runtime)
4869
+ )
4870
+ else:
4871
+ return TeaCore.from_map(
4872
+ fc20230330_models.ListTriggersResponse(),
4873
+ await self.execute_async(params, req, runtime)
4874
+ )
4359
4875
 
4360
4876
  def list_triggers(
4361
4877
  self,
@@ -4414,10 +4930,16 @@ class Client(OpenApiClient):
4414
4930
  req_body_type='json',
4415
4931
  body_type='json'
4416
4932
  )
4417
- return TeaCore.from_map(
4418
- fc20230330_models.ListVpcBindingsResponse(),
4419
- self.call_api(params, req, runtime)
4420
- )
4933
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4934
+ return TeaCore.from_map(
4935
+ fc20230330_models.ListVpcBindingsResponse(),
4936
+ self.call_api(params, req, runtime)
4937
+ )
4938
+ else:
4939
+ return TeaCore.from_map(
4940
+ fc20230330_models.ListVpcBindingsResponse(),
4941
+ self.execute(params, req, runtime)
4942
+ )
4421
4943
 
4422
4944
  async def list_vpc_bindings_with_options_async(
4423
4945
  self,
@@ -4446,10 +4968,16 @@ class Client(OpenApiClient):
4446
4968
  req_body_type='json',
4447
4969
  body_type='json'
4448
4970
  )
4449
- return TeaCore.from_map(
4450
- fc20230330_models.ListVpcBindingsResponse(),
4451
- await self.call_api_async(params, req, runtime)
4452
- )
4971
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
4972
+ return TeaCore.from_map(
4973
+ fc20230330_models.ListVpcBindingsResponse(),
4974
+ await self.call_api_async(params, req, runtime)
4975
+ )
4976
+ else:
4977
+ return TeaCore.from_map(
4978
+ fc20230330_models.ListVpcBindingsResponse(),
4979
+ await self.execute_async(params, req, runtime)
4980
+ )
4453
4981
 
4454
4982
  def list_vpc_bindings(
4455
4983
  self,
@@ -4508,10 +5036,16 @@ class Client(OpenApiClient):
4508
5036
  req_body_type='json',
4509
5037
  body_type='json'
4510
5038
  )
4511
- return TeaCore.from_map(
4512
- fc20230330_models.PublishFunctionVersionResponse(),
4513
- self.call_api(params, req, runtime)
4514
- )
5039
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5040
+ return TeaCore.from_map(
5041
+ fc20230330_models.PublishFunctionVersionResponse(),
5042
+ self.call_api(params, req, runtime)
5043
+ )
5044
+ else:
5045
+ return TeaCore.from_map(
5046
+ fc20230330_models.PublishFunctionVersionResponse(),
5047
+ self.execute(params, req, runtime)
5048
+ )
4515
5049
 
4516
5050
  async def publish_function_version_with_options_async(
4517
5051
  self,
@@ -4544,10 +5078,16 @@ class Client(OpenApiClient):
4544
5078
  req_body_type='json',
4545
5079
  body_type='json'
4546
5080
  )
4547
- return TeaCore.from_map(
4548
- fc20230330_models.PublishFunctionVersionResponse(),
4549
- await self.call_api_async(params, req, runtime)
4550
- )
5081
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5082
+ return TeaCore.from_map(
5083
+ fc20230330_models.PublishFunctionVersionResponse(),
5084
+ await self.call_api_async(params, req, runtime)
5085
+ )
5086
+ else:
5087
+ return TeaCore.from_map(
5088
+ fc20230330_models.PublishFunctionVersionResponse(),
5089
+ await self.execute_async(params, req, runtime)
5090
+ )
4551
5091
 
4552
5092
  def publish_function_version(
4553
5093
  self,
@@ -4614,10 +5154,16 @@ class Client(OpenApiClient):
4614
5154
  req_body_type='json',
4615
5155
  body_type='json'
4616
5156
  )
4617
- return TeaCore.from_map(
4618
- fc20230330_models.PutAsyncInvokeConfigResponse(),
4619
- self.call_api(params, req, runtime)
4620
- )
5157
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5158
+ return TeaCore.from_map(
5159
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5160
+ self.call_api(params, req, runtime)
5161
+ )
5162
+ else:
5163
+ return TeaCore.from_map(
5164
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5165
+ self.execute(params, req, runtime)
5166
+ )
4621
5167
 
4622
5168
  async def put_async_invoke_config_with_options_async(
4623
5169
  self,
@@ -4654,10 +5200,16 @@ class Client(OpenApiClient):
4654
5200
  req_body_type='json',
4655
5201
  body_type='json'
4656
5202
  )
4657
- return TeaCore.from_map(
4658
- fc20230330_models.PutAsyncInvokeConfigResponse(),
4659
- await self.call_api_async(params, req, runtime)
4660
- )
5203
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5204
+ return TeaCore.from_map(
5205
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5206
+ await self.call_api_async(params, req, runtime)
5207
+ )
5208
+ else:
5209
+ return TeaCore.from_map(
5210
+ fc20230330_models.PutAsyncInvokeConfigResponse(),
5211
+ await self.execute_async(params, req, runtime)
5212
+ )
4661
5213
 
4662
5214
  def put_async_invoke_config(
4663
5215
  self,
@@ -4720,10 +5272,16 @@ class Client(OpenApiClient):
4720
5272
  req_body_type='json',
4721
5273
  body_type='json'
4722
5274
  )
4723
- return TeaCore.from_map(
4724
- fc20230330_models.PutConcurrencyConfigResponse(),
4725
- self.call_api(params, req, runtime)
4726
- )
5275
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5276
+ return TeaCore.from_map(
5277
+ fc20230330_models.PutConcurrencyConfigResponse(),
5278
+ self.call_api(params, req, runtime)
5279
+ )
5280
+ else:
5281
+ return TeaCore.from_map(
5282
+ fc20230330_models.PutConcurrencyConfigResponse(),
5283
+ self.execute(params, req, runtime)
5284
+ )
4727
5285
 
4728
5286
  async def put_concurrency_config_with_options_async(
4729
5287
  self,
@@ -4756,10 +5314,16 @@ class Client(OpenApiClient):
4756
5314
  req_body_type='json',
4757
5315
  body_type='json'
4758
5316
  )
4759
- return TeaCore.from_map(
4760
- fc20230330_models.PutConcurrencyConfigResponse(),
4761
- await self.call_api_async(params, req, runtime)
4762
- )
5317
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5318
+ return TeaCore.from_map(
5319
+ fc20230330_models.PutConcurrencyConfigResponse(),
5320
+ await self.call_api_async(params, req, runtime)
5321
+ )
5322
+ else:
5323
+ return TeaCore.from_map(
5324
+ fc20230330_models.PutConcurrencyConfigResponse(),
5325
+ await self.execute_async(params, req, runtime)
5326
+ )
4763
5327
 
4764
5328
  def put_concurrency_config(
4765
5329
  self,
@@ -4827,10 +5391,16 @@ class Client(OpenApiClient):
4827
5391
  req_body_type='json',
4828
5392
  body_type='none'
4829
5393
  )
4830
- return TeaCore.from_map(
4831
- fc20230330_models.PutLayerACLResponse(),
4832
- self.call_api(params, req, runtime)
4833
- )
5394
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5395
+ return TeaCore.from_map(
5396
+ fc20230330_models.PutLayerACLResponse(),
5397
+ self.call_api(params, req, runtime)
5398
+ )
5399
+ else:
5400
+ return TeaCore.from_map(
5401
+ fc20230330_models.PutLayerACLResponse(),
5402
+ self.execute(params, req, runtime)
5403
+ )
4834
5404
 
4835
5405
  async def put_layer_aclwith_options_async(
4836
5406
  self,
@@ -4868,10 +5438,16 @@ class Client(OpenApiClient):
4868
5438
  req_body_type='json',
4869
5439
  body_type='none'
4870
5440
  )
4871
- return TeaCore.from_map(
4872
- fc20230330_models.PutLayerACLResponse(),
4873
- await self.call_api_async(params, req, runtime)
4874
- )
5441
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5442
+ return TeaCore.from_map(
5443
+ fc20230330_models.PutLayerACLResponse(),
5444
+ await self.call_api_async(params, req, runtime)
5445
+ )
5446
+ else:
5447
+ return TeaCore.from_map(
5448
+ fc20230330_models.PutLayerACLResponse(),
5449
+ await self.execute_async(params, req, runtime)
5450
+ )
4875
5451
 
4876
5452
  def put_layer_acl(
4877
5453
  self,
@@ -4938,10 +5514,16 @@ class Client(OpenApiClient):
4938
5514
  req_body_type='json',
4939
5515
  body_type='json'
4940
5516
  )
4941
- return TeaCore.from_map(
4942
- fc20230330_models.PutProvisionConfigResponse(),
4943
- self.call_api(params, req, runtime)
4944
- )
5517
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5518
+ return TeaCore.from_map(
5519
+ fc20230330_models.PutProvisionConfigResponse(),
5520
+ self.call_api(params, req, runtime)
5521
+ )
5522
+ else:
5523
+ return TeaCore.from_map(
5524
+ fc20230330_models.PutProvisionConfigResponse(),
5525
+ self.execute(params, req, runtime)
5526
+ )
4945
5527
 
4946
5528
  async def put_provision_config_with_options_async(
4947
5529
  self,
@@ -4978,10 +5560,16 @@ class Client(OpenApiClient):
4978
5560
  req_body_type='json',
4979
5561
  body_type='json'
4980
5562
  )
4981
- return TeaCore.from_map(
4982
- fc20230330_models.PutProvisionConfigResponse(),
4983
- await self.call_api_async(params, req, runtime)
4984
- )
5563
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5564
+ return TeaCore.from_map(
5565
+ fc20230330_models.PutProvisionConfigResponse(),
5566
+ await self.call_api_async(params, req, runtime)
5567
+ )
5568
+ else:
5569
+ return TeaCore.from_map(
5570
+ fc20230330_models.PutProvisionConfigResponse(),
5571
+ await self.execute_async(params, req, runtime)
5572
+ )
4985
5573
 
4986
5574
  def put_provision_config(
4987
5575
  self,
@@ -5048,10 +5636,16 @@ class Client(OpenApiClient):
5048
5636
  req_body_type='json',
5049
5637
  body_type='none'
5050
5638
  )
5051
- return TeaCore.from_map(
5052
- fc20230330_models.StopAsyncTaskResponse(),
5053
- self.call_api(params, req, runtime)
5054
- )
5639
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5640
+ return TeaCore.from_map(
5641
+ fc20230330_models.StopAsyncTaskResponse(),
5642
+ self.call_api(params, req, runtime)
5643
+ )
5644
+ else:
5645
+ return TeaCore.from_map(
5646
+ fc20230330_models.StopAsyncTaskResponse(),
5647
+ self.execute(params, req, runtime)
5648
+ )
5055
5649
 
5056
5650
  async def stop_async_task_with_options_async(
5057
5651
  self,
@@ -5088,10 +5682,16 @@ class Client(OpenApiClient):
5088
5682
  req_body_type='json',
5089
5683
  body_type='none'
5090
5684
  )
5091
- return TeaCore.from_map(
5092
- fc20230330_models.StopAsyncTaskResponse(),
5093
- await self.call_api_async(params, req, runtime)
5094
- )
5685
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5686
+ return TeaCore.from_map(
5687
+ fc20230330_models.StopAsyncTaskResponse(),
5688
+ await self.call_api_async(params, req, runtime)
5689
+ )
5690
+ else:
5691
+ return TeaCore.from_map(
5692
+ fc20230330_models.StopAsyncTaskResponse(),
5693
+ await self.execute_async(params, req, runtime)
5694
+ )
5095
5695
 
5096
5696
  def stop_async_task(
5097
5697
  self,
@@ -5157,10 +5757,16 @@ class Client(OpenApiClient):
5157
5757
  req_body_type='json',
5158
5758
  body_type='none'
5159
5759
  )
5160
- return TeaCore.from_map(
5161
- fc20230330_models.TagResourcesResponse(),
5162
- self.call_api(params, req, runtime)
5163
- )
5760
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5761
+ return TeaCore.from_map(
5762
+ fc20230330_models.TagResourcesResponse(),
5763
+ self.call_api(params, req, runtime)
5764
+ )
5765
+ else:
5766
+ return TeaCore.from_map(
5767
+ fc20230330_models.TagResourcesResponse(),
5768
+ self.execute(params, req, runtime)
5769
+ )
5164
5770
 
5165
5771
  async def tag_resources_with_options_async(
5166
5772
  self,
@@ -5194,10 +5800,16 @@ class Client(OpenApiClient):
5194
5800
  req_body_type='json',
5195
5801
  body_type='none'
5196
5802
  )
5197
- return TeaCore.from_map(
5198
- fc20230330_models.TagResourcesResponse(),
5199
- await self.call_api_async(params, req, runtime)
5200
- )
5803
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5804
+ return TeaCore.from_map(
5805
+ fc20230330_models.TagResourcesResponse(),
5806
+ await self.call_api_async(params, req, runtime)
5807
+ )
5808
+ else:
5809
+ return TeaCore.from_map(
5810
+ fc20230330_models.TagResourcesResponse(),
5811
+ await self.execute_async(params, req, runtime)
5812
+ )
5201
5813
 
5202
5814
  def tag_resources(
5203
5815
  self,
@@ -5276,10 +5888,16 @@ class Client(OpenApiClient):
5276
5888
  req_body_type='json',
5277
5889
  body_type='none'
5278
5890
  )
5279
- return TeaCore.from_map(
5280
- fc20230330_models.UntagResourcesResponse(),
5281
- self.call_api(params, req, runtime)
5282
- )
5891
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5892
+ return TeaCore.from_map(
5893
+ fc20230330_models.UntagResourcesResponse(),
5894
+ self.call_api(params, req, runtime)
5895
+ )
5896
+ else:
5897
+ return TeaCore.from_map(
5898
+ fc20230330_models.UntagResourcesResponse(),
5899
+ self.execute(params, req, runtime)
5900
+ )
5283
5901
 
5284
5902
  async def untag_resources_with_options_async(
5285
5903
  self,
@@ -5326,10 +5944,16 @@ class Client(OpenApiClient):
5326
5944
  req_body_type='json',
5327
5945
  body_type='none'
5328
5946
  )
5329
- return TeaCore.from_map(
5330
- fc20230330_models.UntagResourcesResponse(),
5331
- await self.call_api_async(params, req, runtime)
5332
- )
5947
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
5948
+ return TeaCore.from_map(
5949
+ fc20230330_models.UntagResourcesResponse(),
5950
+ await self.call_api_async(params, req, runtime)
5951
+ )
5952
+ else:
5953
+ return TeaCore.from_map(
5954
+ fc20230330_models.UntagResourcesResponse(),
5955
+ await self.execute_async(params, req, runtime)
5956
+ )
5333
5957
 
5334
5958
  def untag_resources(
5335
5959
  self,
@@ -5391,10 +6015,16 @@ class Client(OpenApiClient):
5391
6015
  req_body_type='json',
5392
6016
  body_type='json'
5393
6017
  )
5394
- return TeaCore.from_map(
5395
- fc20230330_models.UpdateAliasResponse(),
5396
- self.call_api(params, req, runtime)
5397
- )
6018
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6019
+ return TeaCore.from_map(
6020
+ fc20230330_models.UpdateAliasResponse(),
6021
+ self.call_api(params, req, runtime)
6022
+ )
6023
+ else:
6024
+ return TeaCore.from_map(
6025
+ fc20230330_models.UpdateAliasResponse(),
6026
+ self.execute(params, req, runtime)
6027
+ )
5398
6028
 
5399
6029
  async def update_alias_with_options_async(
5400
6030
  self,
@@ -5428,10 +6058,16 @@ class Client(OpenApiClient):
5428
6058
  req_body_type='json',
5429
6059
  body_type='json'
5430
6060
  )
5431
- return TeaCore.from_map(
5432
- fc20230330_models.UpdateAliasResponse(),
5433
- await self.call_api_async(params, req, runtime)
5434
- )
6061
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6062
+ return TeaCore.from_map(
6063
+ fc20230330_models.UpdateAliasResponse(),
6064
+ await self.call_api_async(params, req, runtime)
6065
+ )
6066
+ else:
6067
+ return TeaCore.from_map(
6068
+ fc20230330_models.UpdateAliasResponse(),
6069
+ await self.execute_async(params, req, runtime)
6070
+ )
5435
6071
 
5436
6072
  def update_alias(
5437
6073
  self,
@@ -5496,10 +6132,16 @@ class Client(OpenApiClient):
5496
6132
  req_body_type='json',
5497
6133
  body_type='json'
5498
6134
  )
5499
- return TeaCore.from_map(
5500
- fc20230330_models.UpdateCustomDomainResponse(),
5501
- self.call_api(params, req, runtime)
5502
- )
6135
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6136
+ return TeaCore.from_map(
6137
+ fc20230330_models.UpdateCustomDomainResponse(),
6138
+ self.call_api(params, req, runtime)
6139
+ )
6140
+ else:
6141
+ return TeaCore.from_map(
6142
+ fc20230330_models.UpdateCustomDomainResponse(),
6143
+ self.execute(params, req, runtime)
6144
+ )
5503
6145
 
5504
6146
  async def update_custom_domain_with_options_async(
5505
6147
  self,
@@ -5532,10 +6174,16 @@ class Client(OpenApiClient):
5532
6174
  req_body_type='json',
5533
6175
  body_type='json'
5534
6176
  )
5535
- return TeaCore.from_map(
5536
- fc20230330_models.UpdateCustomDomainResponse(),
5537
- await self.call_api_async(params, req, runtime)
5538
- )
6177
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6178
+ return TeaCore.from_map(
6179
+ fc20230330_models.UpdateCustomDomainResponse(),
6180
+ await self.call_api_async(params, req, runtime)
6181
+ )
6182
+ else:
6183
+ return TeaCore.from_map(
6184
+ fc20230330_models.UpdateCustomDomainResponse(),
6185
+ await self.execute_async(params, req, runtime)
6186
+ )
5539
6187
 
5540
6188
  def update_custom_domain(
5541
6189
  self,
@@ -5598,10 +6246,16 @@ class Client(OpenApiClient):
5598
6246
  req_body_type='json',
5599
6247
  body_type='json'
5600
6248
  )
5601
- return TeaCore.from_map(
5602
- fc20230330_models.UpdateFunctionResponse(),
5603
- self.call_api(params, req, runtime)
5604
- )
6249
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6250
+ return TeaCore.from_map(
6251
+ fc20230330_models.UpdateFunctionResponse(),
6252
+ self.call_api(params, req, runtime)
6253
+ )
6254
+ else:
6255
+ return TeaCore.from_map(
6256
+ fc20230330_models.UpdateFunctionResponse(),
6257
+ self.execute(params, req, runtime)
6258
+ )
5605
6259
 
5606
6260
  async def update_function_with_options_async(
5607
6261
  self,
@@ -5634,10 +6288,16 @@ class Client(OpenApiClient):
5634
6288
  req_body_type='json',
5635
6289
  body_type='json'
5636
6290
  )
5637
- return TeaCore.from_map(
5638
- fc20230330_models.UpdateFunctionResponse(),
5639
- await self.call_api_async(params, req, runtime)
5640
- )
6291
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6292
+ return TeaCore.from_map(
6293
+ fc20230330_models.UpdateFunctionResponse(),
6294
+ await self.call_api_async(params, req, runtime)
6295
+ )
6296
+ else:
6297
+ return TeaCore.from_map(
6298
+ fc20230330_models.UpdateFunctionResponse(),
6299
+ await self.execute_async(params, req, runtime)
6300
+ )
5641
6301
 
5642
6302
  def update_function(
5643
6303
  self,
@@ -5701,10 +6361,16 @@ class Client(OpenApiClient):
5701
6361
  req_body_type='json',
5702
6362
  body_type='json'
5703
6363
  )
5704
- return TeaCore.from_map(
5705
- fc20230330_models.UpdateTriggerResponse(),
5706
- self.call_api(params, req, runtime)
5707
- )
6364
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6365
+ return TeaCore.from_map(
6366
+ fc20230330_models.UpdateTriggerResponse(),
6367
+ self.call_api(params, req, runtime)
6368
+ )
6369
+ else:
6370
+ return TeaCore.from_map(
6371
+ fc20230330_models.UpdateTriggerResponse(),
6372
+ self.execute(params, req, runtime)
6373
+ )
5708
6374
 
5709
6375
  async def update_trigger_with_options_async(
5710
6376
  self,
@@ -5738,10 +6404,16 @@ class Client(OpenApiClient):
5738
6404
  req_body_type='json',
5739
6405
  body_type='json'
5740
6406
  )
5741
- return TeaCore.from_map(
5742
- fc20230330_models.UpdateTriggerResponse(),
5743
- await self.call_api_async(params, req, runtime)
5744
- )
6407
+ if UtilClient.is_unset(self._signature_version) or not UtilClient.equal_string(self._signature_version, 'v4'):
6408
+ return TeaCore.from_map(
6409
+ fc20230330_models.UpdateTriggerResponse(),
6410
+ await self.call_api_async(params, req, runtime)
6411
+ )
6412
+ else:
6413
+ return TeaCore.from_map(
6414
+ fc20230330_models.UpdateTriggerResponse(),
6415
+ await self.execute_async(params, req, runtime)
6416
+ )
5745
6417
 
5746
6418
  def update_trigger(
5747
6419
  self,