alibabacloud-fc20230330 4.1.6__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 +1060 -424
  3. alibabacloud_fc20230330/models.py +97 -0
  4. {alibabacloud_fc20230330-4.1.6.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.6.dist-info/RECORD +0 -8
  7. {alibabacloud_fc20230330-4.1.6.dist-info → alibabacloud_fc20230330-4.1.7.dist-info}/LICENSE +0 -0
  8. {alibabacloud_fc20230330-4.1.6.dist-info → alibabacloud_fc20230330-4.1.7.dist-info}/WHEEL +0 -0
  9. {alibabacloud_fc20230330-4.1.6.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,
@@ -3737,10 +4145,16 @@ class Client(OpenApiClient):
3737
4145
  req_body_type='json',
3738
4146
  body_type='json'
3739
4147
  )
3740
- return TeaCore.from_map(
3741
- fc20230330_models.ListInstancesResponse(),
3742
- self.call_api(params, req, runtime)
3743
- )
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
+ )
3744
4158
 
3745
4159
  async def list_instances_with_options_async(
3746
4160
  self,
@@ -3796,10 +4210,16 @@ class Client(OpenApiClient):
3796
4210
  req_body_type='json',
3797
4211
  body_type='json'
3798
4212
  )
3799
- return TeaCore.from_map(
3800
- fc20230330_models.ListInstancesResponse(),
3801
- await self.call_api_async(params, req, runtime)
3802
- )
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
+ )
3803
4223
 
3804
4224
  def list_instances(
3805
4225
  self,
@@ -3867,10 +4287,16 @@ class Client(OpenApiClient):
3867
4287
  req_body_type='json',
3868
4288
  body_type='json'
3869
4289
  )
3870
- return TeaCore.from_map(
3871
- fc20230330_models.ListLayerVersionsResponse(),
3872
- self.call_api(params, req, runtime)
3873
- )
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
+ )
3874
4300
 
3875
4301
  async def list_layer_versions_with_options_async(
3876
4302
  self,
@@ -3908,10 +4334,16 @@ class Client(OpenApiClient):
3908
4334
  req_body_type='json',
3909
4335
  body_type='json'
3910
4336
  )
3911
- return TeaCore.from_map(
3912
- fc20230330_models.ListLayerVersionsResponse(),
3913
- await self.call_api_async(params, req, runtime)
3914
- )
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
+ )
3915
4347
 
3916
4348
  def list_layer_versions(
3917
4349
  self,
@@ -3984,10 +4416,16 @@ class Client(OpenApiClient):
3984
4416
  req_body_type='json',
3985
4417
  body_type='json'
3986
4418
  )
3987
- return TeaCore.from_map(
3988
- fc20230330_models.ListLayersResponse(),
3989
- self.call_api(params, req, runtime)
3990
- )
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
+ )
3991
4429
 
3992
4430
  async def list_layers_with_options_async(
3993
4431
  self,
@@ -4030,10 +4468,16 @@ class Client(OpenApiClient):
4030
4468
  req_body_type='json',
4031
4469
  body_type='json'
4032
4470
  )
4033
- return TeaCore.from_map(
4034
- fc20230330_models.ListLayersResponse(),
4035
- await self.call_api_async(params, req, runtime)
4036
- )
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
+ )
4037
4481
 
4038
4482
  def list_layers(
4039
4483
  self,
@@ -4100,10 +4544,16 @@ class Client(OpenApiClient):
4100
4544
  req_body_type='json',
4101
4545
  body_type='json'
4102
4546
  )
4103
- return TeaCore.from_map(
4104
- fc20230330_models.ListProvisionConfigsResponse(),
4105
- self.call_api(params, req, runtime)
4106
- )
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
+ )
4107
4557
 
4108
4558
  async def list_provision_configs_with_options_async(
4109
4559
  self,
@@ -4142,10 +4592,16 @@ class Client(OpenApiClient):
4142
4592
  req_body_type='json',
4143
4593
  body_type='json'
4144
4594
  )
4145
- return TeaCore.from_map(
4146
- fc20230330_models.ListProvisionConfigsResponse(),
4147
- await self.call_api_async(params, req, runtime)
4148
- )
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
+ )
4149
4605
 
4150
4606
  def list_provision_configs(
4151
4607
  self,
@@ -4222,10 +4678,16 @@ class Client(OpenApiClient):
4222
4678
  req_body_type='json',
4223
4679
  body_type='json'
4224
4680
  )
4225
- return TeaCore.from_map(
4226
- fc20230330_models.ListTagResourcesResponse(),
4227
- self.call_api(params, req, runtime)
4228
- )
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
+ )
4229
4691
 
4230
4692
  async def list_tag_resources_with_options_async(
4231
4693
  self,
@@ -4274,10 +4736,16 @@ class Client(OpenApiClient):
4274
4736
  req_body_type='json',
4275
4737
  body_type='json'
4276
4738
  )
4277
- return TeaCore.from_map(
4278
- fc20230330_models.ListTagResourcesResponse(),
4279
- await self.call_api_async(params, req, runtime)
4280
- )
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
+ )
4281
4749
 
4282
4750
  def list_tag_resources(
4283
4751
  self,
@@ -4345,10 +4813,16 @@ class Client(OpenApiClient):
4345
4813
  req_body_type='json',
4346
4814
  body_type='json'
4347
4815
  )
4348
- return TeaCore.from_map(
4349
- fc20230330_models.ListTriggersResponse(),
4350
- self.call_api(params, req, runtime)
4351
- )
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
+ )
4352
4826
 
4353
4827
  async def list_triggers_with_options_async(
4354
4828
  self,
@@ -4388,10 +4862,16 @@ class Client(OpenApiClient):
4388
4862
  req_body_type='json',
4389
4863
  body_type='json'
4390
4864
  )
4391
- return TeaCore.from_map(
4392
- fc20230330_models.ListTriggersResponse(),
4393
- await self.call_api_async(params, req, runtime)
4394
- )
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
+ )
4395
4875
 
4396
4876
  def list_triggers(
4397
4877
  self,
@@ -4450,10 +4930,16 @@ class Client(OpenApiClient):
4450
4930
  req_body_type='json',
4451
4931
  body_type='json'
4452
4932
  )
4453
- return TeaCore.from_map(
4454
- fc20230330_models.ListVpcBindingsResponse(),
4455
- self.call_api(params, req, runtime)
4456
- )
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
+ )
4457
4943
 
4458
4944
  async def list_vpc_bindings_with_options_async(
4459
4945
  self,
@@ -4482,10 +4968,16 @@ class Client(OpenApiClient):
4482
4968
  req_body_type='json',
4483
4969
  body_type='json'
4484
4970
  )
4485
- return TeaCore.from_map(
4486
- fc20230330_models.ListVpcBindingsResponse(),
4487
- await self.call_api_async(params, req, runtime)
4488
- )
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
+ )
4489
4981
 
4490
4982
  def list_vpc_bindings(
4491
4983
  self,
@@ -4544,10 +5036,16 @@ class Client(OpenApiClient):
4544
5036
  req_body_type='json',
4545
5037
  body_type='json'
4546
5038
  )
4547
- return TeaCore.from_map(
4548
- fc20230330_models.PublishFunctionVersionResponse(),
4549
- self.call_api(params, req, runtime)
4550
- )
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
+ )
4551
5049
 
4552
5050
  async def publish_function_version_with_options_async(
4553
5051
  self,
@@ -4580,10 +5078,16 @@ class Client(OpenApiClient):
4580
5078
  req_body_type='json',
4581
5079
  body_type='json'
4582
5080
  )
4583
- return TeaCore.from_map(
4584
- fc20230330_models.PublishFunctionVersionResponse(),
4585
- await self.call_api_async(params, req, runtime)
4586
- )
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
+ )
4587
5091
 
4588
5092
  def publish_function_version(
4589
5093
  self,
@@ -4650,10 +5154,16 @@ class Client(OpenApiClient):
4650
5154
  req_body_type='json',
4651
5155
  body_type='json'
4652
5156
  )
4653
- return TeaCore.from_map(
4654
- fc20230330_models.PutAsyncInvokeConfigResponse(),
4655
- self.call_api(params, req, runtime)
4656
- )
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
+ )
4657
5167
 
4658
5168
  async def put_async_invoke_config_with_options_async(
4659
5169
  self,
@@ -4690,10 +5200,16 @@ class Client(OpenApiClient):
4690
5200
  req_body_type='json',
4691
5201
  body_type='json'
4692
5202
  )
4693
- return TeaCore.from_map(
4694
- fc20230330_models.PutAsyncInvokeConfigResponse(),
4695
- await self.call_api_async(params, req, runtime)
4696
- )
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
+ )
4697
5213
 
4698
5214
  def put_async_invoke_config(
4699
5215
  self,
@@ -4756,10 +5272,16 @@ class Client(OpenApiClient):
4756
5272
  req_body_type='json',
4757
5273
  body_type='json'
4758
5274
  )
4759
- return TeaCore.from_map(
4760
- fc20230330_models.PutConcurrencyConfigResponse(),
4761
- self.call_api(params, req, runtime)
4762
- )
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
+ )
4763
5285
 
4764
5286
  async def put_concurrency_config_with_options_async(
4765
5287
  self,
@@ -4792,10 +5314,16 @@ class Client(OpenApiClient):
4792
5314
  req_body_type='json',
4793
5315
  body_type='json'
4794
5316
  )
4795
- return TeaCore.from_map(
4796
- fc20230330_models.PutConcurrencyConfigResponse(),
4797
- await self.call_api_async(params, req, runtime)
4798
- )
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
+ )
4799
5327
 
4800
5328
  def put_concurrency_config(
4801
5329
  self,
@@ -4863,10 +5391,16 @@ class Client(OpenApiClient):
4863
5391
  req_body_type='json',
4864
5392
  body_type='none'
4865
5393
  )
4866
- return TeaCore.from_map(
4867
- fc20230330_models.PutLayerACLResponse(),
4868
- self.call_api(params, req, runtime)
4869
- )
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
+ )
4870
5404
 
4871
5405
  async def put_layer_aclwith_options_async(
4872
5406
  self,
@@ -4904,10 +5438,16 @@ class Client(OpenApiClient):
4904
5438
  req_body_type='json',
4905
5439
  body_type='none'
4906
5440
  )
4907
- return TeaCore.from_map(
4908
- fc20230330_models.PutLayerACLResponse(),
4909
- await self.call_api_async(params, req, runtime)
4910
- )
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
+ )
4911
5451
 
4912
5452
  def put_layer_acl(
4913
5453
  self,
@@ -4974,10 +5514,16 @@ class Client(OpenApiClient):
4974
5514
  req_body_type='json',
4975
5515
  body_type='json'
4976
5516
  )
4977
- return TeaCore.from_map(
4978
- fc20230330_models.PutProvisionConfigResponse(),
4979
- self.call_api(params, req, runtime)
4980
- )
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
+ )
4981
5527
 
4982
5528
  async def put_provision_config_with_options_async(
4983
5529
  self,
@@ -5014,10 +5560,16 @@ class Client(OpenApiClient):
5014
5560
  req_body_type='json',
5015
5561
  body_type='json'
5016
5562
  )
5017
- return TeaCore.from_map(
5018
- fc20230330_models.PutProvisionConfigResponse(),
5019
- await self.call_api_async(params, req, runtime)
5020
- )
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
+ )
5021
5573
 
5022
5574
  def put_provision_config(
5023
5575
  self,
@@ -5084,10 +5636,16 @@ class Client(OpenApiClient):
5084
5636
  req_body_type='json',
5085
5637
  body_type='none'
5086
5638
  )
5087
- return TeaCore.from_map(
5088
- fc20230330_models.StopAsyncTaskResponse(),
5089
- self.call_api(params, req, runtime)
5090
- )
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
+ )
5091
5649
 
5092
5650
  async def stop_async_task_with_options_async(
5093
5651
  self,
@@ -5124,10 +5682,16 @@ class Client(OpenApiClient):
5124
5682
  req_body_type='json',
5125
5683
  body_type='none'
5126
5684
  )
5127
- return TeaCore.from_map(
5128
- fc20230330_models.StopAsyncTaskResponse(),
5129
- await self.call_api_async(params, req, runtime)
5130
- )
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
+ )
5131
5695
 
5132
5696
  def stop_async_task(
5133
5697
  self,
@@ -5193,10 +5757,16 @@ class Client(OpenApiClient):
5193
5757
  req_body_type='json',
5194
5758
  body_type='none'
5195
5759
  )
5196
- return TeaCore.from_map(
5197
- fc20230330_models.TagResourcesResponse(),
5198
- self.call_api(params, req, runtime)
5199
- )
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
+ )
5200
5770
 
5201
5771
  async def tag_resources_with_options_async(
5202
5772
  self,
@@ -5230,10 +5800,16 @@ class Client(OpenApiClient):
5230
5800
  req_body_type='json',
5231
5801
  body_type='none'
5232
5802
  )
5233
- return TeaCore.from_map(
5234
- fc20230330_models.TagResourcesResponse(),
5235
- await self.call_api_async(params, req, runtime)
5236
- )
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
+ )
5237
5813
 
5238
5814
  def tag_resources(
5239
5815
  self,
@@ -5312,10 +5888,16 @@ class Client(OpenApiClient):
5312
5888
  req_body_type='json',
5313
5889
  body_type='none'
5314
5890
  )
5315
- return TeaCore.from_map(
5316
- fc20230330_models.UntagResourcesResponse(),
5317
- self.call_api(params, req, runtime)
5318
- )
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
+ )
5319
5901
 
5320
5902
  async def untag_resources_with_options_async(
5321
5903
  self,
@@ -5362,10 +5944,16 @@ class Client(OpenApiClient):
5362
5944
  req_body_type='json',
5363
5945
  body_type='none'
5364
5946
  )
5365
- return TeaCore.from_map(
5366
- fc20230330_models.UntagResourcesResponse(),
5367
- await self.call_api_async(params, req, runtime)
5368
- )
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
+ )
5369
5957
 
5370
5958
  def untag_resources(
5371
5959
  self,
@@ -5427,10 +6015,16 @@ class Client(OpenApiClient):
5427
6015
  req_body_type='json',
5428
6016
  body_type='json'
5429
6017
  )
5430
- return TeaCore.from_map(
5431
- fc20230330_models.UpdateAliasResponse(),
5432
- self.call_api(params, req, runtime)
5433
- )
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
+ )
5434
6028
 
5435
6029
  async def update_alias_with_options_async(
5436
6030
  self,
@@ -5464,10 +6058,16 @@ class Client(OpenApiClient):
5464
6058
  req_body_type='json',
5465
6059
  body_type='json'
5466
6060
  )
5467
- return TeaCore.from_map(
5468
- fc20230330_models.UpdateAliasResponse(),
5469
- await self.call_api_async(params, req, runtime)
5470
- )
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
+ )
5471
6071
 
5472
6072
  def update_alias(
5473
6073
  self,
@@ -5532,10 +6132,16 @@ class Client(OpenApiClient):
5532
6132
  req_body_type='json',
5533
6133
  body_type='json'
5534
6134
  )
5535
- return TeaCore.from_map(
5536
- fc20230330_models.UpdateCustomDomainResponse(),
5537
- self.call_api(params, req, runtime)
5538
- )
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
+ )
5539
6145
 
5540
6146
  async def update_custom_domain_with_options_async(
5541
6147
  self,
@@ -5568,10 +6174,16 @@ class Client(OpenApiClient):
5568
6174
  req_body_type='json',
5569
6175
  body_type='json'
5570
6176
  )
5571
- return TeaCore.from_map(
5572
- fc20230330_models.UpdateCustomDomainResponse(),
5573
- await self.call_api_async(params, req, runtime)
5574
- )
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
+ )
5575
6187
 
5576
6188
  def update_custom_domain(
5577
6189
  self,
@@ -5634,10 +6246,16 @@ class Client(OpenApiClient):
5634
6246
  req_body_type='json',
5635
6247
  body_type='json'
5636
6248
  )
5637
- return TeaCore.from_map(
5638
- fc20230330_models.UpdateFunctionResponse(),
5639
- self.call_api(params, req, runtime)
5640
- )
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
+ )
5641
6259
 
5642
6260
  async def update_function_with_options_async(
5643
6261
  self,
@@ -5670,10 +6288,16 @@ class Client(OpenApiClient):
5670
6288
  req_body_type='json',
5671
6289
  body_type='json'
5672
6290
  )
5673
- return TeaCore.from_map(
5674
- fc20230330_models.UpdateFunctionResponse(),
5675
- await self.call_api_async(params, req, runtime)
5676
- )
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
+ )
5677
6301
 
5678
6302
  def update_function(
5679
6303
  self,
@@ -5737,10 +6361,16 @@ class Client(OpenApiClient):
5737
6361
  req_body_type='json',
5738
6362
  body_type='json'
5739
6363
  )
5740
- return TeaCore.from_map(
5741
- fc20230330_models.UpdateTriggerResponse(),
5742
- self.call_api(params, req, runtime)
5743
- )
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
+ )
5744
6374
 
5745
6375
  async def update_trigger_with_options_async(
5746
6376
  self,
@@ -5774,10 +6404,16 @@ class Client(OpenApiClient):
5774
6404
  req_body_type='json',
5775
6405
  body_type='json'
5776
6406
  )
5777
- return TeaCore.from_map(
5778
- fc20230330_models.UpdateTriggerResponse(),
5779
- await self.call_api_async(params, req, runtime)
5780
- )
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
+ )
5781
6417
 
5782
6418
  def update_trigger(
5783
6419
  self,