@aws-sdk/client-datazone 3.504.0 → 3.507.0

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.
package/dist-cjs/index.js CHANGED
@@ -3418,7 +3418,7 @@ var se_UpdateUserProfileCommand = /* @__PURE__ */ __name(async (input, context)
3418
3418
  }, "se_UpdateUserProfileCommand");
3419
3419
  var de_AcceptPredictionsCommand = /* @__PURE__ */ __name(async (output, context) => {
3420
3420
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3421
- return de_AcceptPredictionsCommandError(output, context);
3421
+ return de_CommandError(output, context);
3422
3422
  }
3423
3423
  const contents = (0, import_smithy_client.map)({
3424
3424
  $metadata: deserializeMetadata(output)
@@ -3432,46 +3432,9 @@ var de_AcceptPredictionsCommand = /* @__PURE__ */ __name(async (output, context)
3432
3432
  Object.assign(contents, doc);
3433
3433
  return contents;
3434
3434
  }, "de_AcceptPredictionsCommand");
3435
- var de_AcceptPredictionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3436
- const parsedOutput = {
3437
- ...output,
3438
- body: await parseErrorBody(output.body, context)
3439
- };
3440
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3441
- switch (errorCode) {
3442
- case "AccessDeniedException":
3443
- case "com.amazonaws.datazone#AccessDeniedException":
3444
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3445
- case "ConflictException":
3446
- case "com.amazonaws.datazone#ConflictException":
3447
- throw await de_ConflictExceptionRes(parsedOutput, context);
3448
- case "InternalServerException":
3449
- case "com.amazonaws.datazone#InternalServerException":
3450
- throw await de_InternalServerExceptionRes(parsedOutput, context);
3451
- case "ResourceNotFoundException":
3452
- case "com.amazonaws.datazone#ResourceNotFoundException":
3453
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3454
- case "ThrottlingException":
3455
- case "com.amazonaws.datazone#ThrottlingException":
3456
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
3457
- case "UnauthorizedException":
3458
- case "com.amazonaws.datazone#UnauthorizedException":
3459
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3460
- case "ValidationException":
3461
- case "com.amazonaws.datazone#ValidationException":
3462
- throw await de_ValidationExceptionRes(parsedOutput, context);
3463
- default:
3464
- const parsedBody = parsedOutput.body;
3465
- return throwDefaultError({
3466
- output,
3467
- parsedBody,
3468
- errorCode
3469
- });
3470
- }
3471
- }, "de_AcceptPredictionsCommandError");
3472
3435
  var de_AcceptSubscriptionRequestCommand = /* @__PURE__ */ __name(async (output, context) => {
3473
3436
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3474
- return de_AcceptSubscriptionRequestCommandError(output, context);
3437
+ return de_CommandError(output, context);
3475
3438
  }
3476
3439
  const contents = (0, import_smithy_client.map)({
3477
3440
  $metadata: deserializeMetadata(output)
@@ -3494,46 +3457,9 @@ var de_AcceptSubscriptionRequestCommand = /* @__PURE__ */ __name(async (output,
3494
3457
  Object.assign(contents, doc);
3495
3458
  return contents;
3496
3459
  }, "de_AcceptSubscriptionRequestCommand");
3497
- var de_AcceptSubscriptionRequestCommandError = /* @__PURE__ */ __name(async (output, context) => {
3498
- const parsedOutput = {
3499
- ...output,
3500
- body: await parseErrorBody(output.body, context)
3501
- };
3502
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3503
- switch (errorCode) {
3504
- case "AccessDeniedException":
3505
- case "com.amazonaws.datazone#AccessDeniedException":
3506
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3507
- case "ConflictException":
3508
- case "com.amazonaws.datazone#ConflictException":
3509
- throw await de_ConflictExceptionRes(parsedOutput, context);
3510
- case "InternalServerException":
3511
- case "com.amazonaws.datazone#InternalServerException":
3512
- throw await de_InternalServerExceptionRes(parsedOutput, context);
3513
- case "ResourceNotFoundException":
3514
- case "com.amazonaws.datazone#ResourceNotFoundException":
3515
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3516
- case "ThrottlingException":
3517
- case "com.amazonaws.datazone#ThrottlingException":
3518
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
3519
- case "UnauthorizedException":
3520
- case "com.amazonaws.datazone#UnauthorizedException":
3521
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3522
- case "ValidationException":
3523
- case "com.amazonaws.datazone#ValidationException":
3524
- throw await de_ValidationExceptionRes(parsedOutput, context);
3525
- default:
3526
- const parsedBody = parsedOutput.body;
3527
- return throwDefaultError({
3528
- output,
3529
- parsedBody,
3530
- errorCode
3531
- });
3532
- }
3533
- }, "de_AcceptSubscriptionRequestCommandError");
3534
3460
  var de_CancelSubscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
3535
3461
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3536
- return de_CancelSubscriptionCommandError(output, context);
3462
+ return de_CommandError(output, context);
3537
3463
  }
3538
3464
  const contents = (0, import_smithy_client.map)({
3539
3465
  $metadata: deserializeMetadata(output)
@@ -3555,46 +3481,9 @@ var de_CancelSubscriptionCommand = /* @__PURE__ */ __name(async (output, context
3555
3481
  Object.assign(contents, doc);
3556
3482
  return contents;
3557
3483
  }, "de_CancelSubscriptionCommand");
3558
- var de_CancelSubscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
3559
- const parsedOutput = {
3560
- ...output,
3561
- body: await parseErrorBody(output.body, context)
3562
- };
3563
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3564
- switch (errorCode) {
3565
- case "AccessDeniedException":
3566
- case "com.amazonaws.datazone#AccessDeniedException":
3567
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3568
- case "ConflictException":
3569
- case "com.amazonaws.datazone#ConflictException":
3570
- throw await de_ConflictExceptionRes(parsedOutput, context);
3571
- case "InternalServerException":
3572
- case "com.amazonaws.datazone#InternalServerException":
3573
- throw await de_InternalServerExceptionRes(parsedOutput, context);
3574
- case "ResourceNotFoundException":
3575
- case "com.amazonaws.datazone#ResourceNotFoundException":
3576
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3577
- case "ThrottlingException":
3578
- case "com.amazonaws.datazone#ThrottlingException":
3579
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
3580
- case "UnauthorizedException":
3581
- case "com.amazonaws.datazone#UnauthorizedException":
3582
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3583
- case "ValidationException":
3584
- case "com.amazonaws.datazone#ValidationException":
3585
- throw await de_ValidationExceptionRes(parsedOutput, context);
3586
- default:
3587
- const parsedBody = parsedOutput.body;
3588
- return throwDefaultError({
3589
- output,
3590
- parsedBody,
3591
- errorCode
3592
- });
3593
- }
3594
- }, "de_CancelSubscriptionCommandError");
3595
3484
  var de_CreateAssetCommand = /* @__PURE__ */ __name(async (output, context) => {
3596
3485
  if (output.statusCode !== 201 && output.statusCode >= 300) {
3597
- return de_CreateAssetCommandError(output, context);
3486
+ return de_CommandError(output, context);
3598
3487
  }
3599
3488
  const contents = (0, import_smithy_client.map)({
3600
3489
  $metadata: deserializeMetadata(output)
@@ -3623,49 +3512,9 @@ var de_CreateAssetCommand = /* @__PURE__ */ __name(async (output, context) => {
3623
3512
  Object.assign(contents, doc);
3624
3513
  return contents;
3625
3514
  }, "de_CreateAssetCommand");
3626
- var de_CreateAssetCommandError = /* @__PURE__ */ __name(async (output, context) => {
3627
- const parsedOutput = {
3628
- ...output,
3629
- body: await parseErrorBody(output.body, context)
3630
- };
3631
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3632
- switch (errorCode) {
3633
- case "AccessDeniedException":
3634
- case "com.amazonaws.datazone#AccessDeniedException":
3635
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3636
- case "ConflictException":
3637
- case "com.amazonaws.datazone#ConflictException":
3638
- throw await de_ConflictExceptionRes(parsedOutput, context);
3639
- case "InternalServerException":
3640
- case "com.amazonaws.datazone#InternalServerException":
3641
- throw await de_InternalServerExceptionRes(parsedOutput, context);
3642
- case "ResourceNotFoundException":
3643
- case "com.amazonaws.datazone#ResourceNotFoundException":
3644
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3645
- case "ServiceQuotaExceededException":
3646
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
3647
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
3648
- case "ThrottlingException":
3649
- case "com.amazonaws.datazone#ThrottlingException":
3650
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
3651
- case "UnauthorizedException":
3652
- case "com.amazonaws.datazone#UnauthorizedException":
3653
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3654
- case "ValidationException":
3655
- case "com.amazonaws.datazone#ValidationException":
3656
- throw await de_ValidationExceptionRes(parsedOutput, context);
3657
- default:
3658
- const parsedBody = parsedOutput.body;
3659
- return throwDefaultError({
3660
- output,
3661
- parsedBody,
3662
- errorCode
3663
- });
3664
- }
3665
- }, "de_CreateAssetCommandError");
3666
3515
  var de_CreateAssetRevisionCommand = /* @__PURE__ */ __name(async (output, context) => {
3667
3516
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3668
- return de_CreateAssetRevisionCommandError(output, context);
3517
+ return de_CommandError(output, context);
3669
3518
  }
3670
3519
  const contents = (0, import_smithy_client.map)({
3671
3520
  $metadata: deserializeMetadata(output)
@@ -3694,46 +3543,9 @@ var de_CreateAssetRevisionCommand = /* @__PURE__ */ __name(async (output, contex
3694
3543
  Object.assign(contents, doc);
3695
3544
  return contents;
3696
3545
  }, "de_CreateAssetRevisionCommand");
3697
- var de_CreateAssetRevisionCommandError = /* @__PURE__ */ __name(async (output, context) => {
3698
- const parsedOutput = {
3699
- ...output,
3700
- body: await parseErrorBody(output.body, context)
3701
- };
3702
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3703
- switch (errorCode) {
3704
- case "AccessDeniedException":
3705
- case "com.amazonaws.datazone#AccessDeniedException":
3706
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3707
- case "ConflictException":
3708
- case "com.amazonaws.datazone#ConflictException":
3709
- throw await de_ConflictExceptionRes(parsedOutput, context);
3710
- case "InternalServerException":
3711
- case "com.amazonaws.datazone#InternalServerException":
3712
- throw await de_InternalServerExceptionRes(parsedOutput, context);
3713
- case "ResourceNotFoundException":
3714
- case "com.amazonaws.datazone#ResourceNotFoundException":
3715
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3716
- case "ThrottlingException":
3717
- case "com.amazonaws.datazone#ThrottlingException":
3718
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
3719
- case "UnauthorizedException":
3720
- case "com.amazonaws.datazone#UnauthorizedException":
3721
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3722
- case "ValidationException":
3723
- case "com.amazonaws.datazone#ValidationException":
3724
- throw await de_ValidationExceptionRes(parsedOutput, context);
3725
- default:
3726
- const parsedBody = parsedOutput.body;
3727
- return throwDefaultError({
3728
- output,
3729
- parsedBody,
3730
- errorCode
3731
- });
3732
- }
3733
- }, "de_CreateAssetRevisionCommandError");
3734
3546
  var de_CreateAssetTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
3735
3547
  if (output.statusCode !== 201 && output.statusCode >= 300) {
3736
- return de_CreateAssetTypeCommandError(output, context);
3548
+ return de_CommandError(output, context);
3737
3549
  }
3738
3550
  const contents = (0, import_smithy_client.map)({
3739
3551
  $metadata: deserializeMetadata(output)
@@ -3756,46 +3568,9 @@ var de_CreateAssetTypeCommand = /* @__PURE__ */ __name(async (output, context) =
3756
3568
  Object.assign(contents, doc);
3757
3569
  return contents;
3758
3570
  }, "de_CreateAssetTypeCommand");
3759
- var de_CreateAssetTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
3760
- const parsedOutput = {
3761
- ...output,
3762
- body: await parseErrorBody(output.body, context)
3763
- };
3764
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3765
- switch (errorCode) {
3766
- case "AccessDeniedException":
3767
- case "com.amazonaws.datazone#AccessDeniedException":
3768
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3769
- case "ConflictException":
3770
- case "com.amazonaws.datazone#ConflictException":
3771
- throw await de_ConflictExceptionRes(parsedOutput, context);
3772
- case "InternalServerException":
3773
- case "com.amazonaws.datazone#InternalServerException":
3774
- throw await de_InternalServerExceptionRes(parsedOutput, context);
3775
- case "ServiceQuotaExceededException":
3776
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
3777
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
3778
- case "ThrottlingException":
3779
- case "com.amazonaws.datazone#ThrottlingException":
3780
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
3781
- case "UnauthorizedException":
3782
- case "com.amazonaws.datazone#UnauthorizedException":
3783
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3784
- case "ValidationException":
3785
- case "com.amazonaws.datazone#ValidationException":
3786
- throw await de_ValidationExceptionRes(parsedOutput, context);
3787
- default:
3788
- const parsedBody = parsedOutput.body;
3789
- return throwDefaultError({
3790
- output,
3791
- parsedBody,
3792
- errorCode
3793
- });
3794
- }
3795
- }, "de_CreateAssetTypeCommandError");
3796
3571
  var de_CreateDataSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
3797
3572
  if (output.statusCode !== 201 && output.statusCode >= 300) {
3798
- return de_CreateDataSourceCommandError(output, context);
3573
+ return de_CommandError(output, context);
3799
3574
  }
3800
3575
  const contents = (0, import_smithy_client.map)({
3801
3576
  $metadata: deserializeMetadata(output)
@@ -3826,49 +3601,9 @@ var de_CreateDataSourceCommand = /* @__PURE__ */ __name(async (output, context)
3826
3601
  Object.assign(contents, doc);
3827
3602
  return contents;
3828
3603
  }, "de_CreateDataSourceCommand");
3829
- var de_CreateDataSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
3830
- const parsedOutput = {
3831
- ...output,
3832
- body: await parseErrorBody(output.body, context)
3833
- };
3834
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3835
- switch (errorCode) {
3836
- case "AccessDeniedException":
3837
- case "com.amazonaws.datazone#AccessDeniedException":
3838
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3839
- case "ConflictException":
3840
- case "com.amazonaws.datazone#ConflictException":
3841
- throw await de_ConflictExceptionRes(parsedOutput, context);
3842
- case "InternalServerException":
3843
- case "com.amazonaws.datazone#InternalServerException":
3844
- throw await de_InternalServerExceptionRes(parsedOutput, context);
3845
- case "ResourceNotFoundException":
3846
- case "com.amazonaws.datazone#ResourceNotFoundException":
3847
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3848
- case "ServiceQuotaExceededException":
3849
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
3850
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
3851
- case "ThrottlingException":
3852
- case "com.amazonaws.datazone#ThrottlingException":
3853
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
3854
- case "UnauthorizedException":
3855
- case "com.amazonaws.datazone#UnauthorizedException":
3856
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3857
- case "ValidationException":
3858
- case "com.amazonaws.datazone#ValidationException":
3859
- throw await de_ValidationExceptionRes(parsedOutput, context);
3860
- default:
3861
- const parsedBody = parsedOutput.body;
3862
- return throwDefaultError({
3863
- output,
3864
- parsedBody,
3865
- errorCode
3866
- });
3867
- }
3868
- }, "de_CreateDataSourceCommandError");
3869
3604
  var de_CreateDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
3870
3605
  if (output.statusCode !== 201 && output.statusCode >= 300) {
3871
- return de_CreateDomainCommandError(output, context);
3606
+ return de_CommandError(output, context);
3872
3607
  }
3873
3608
  const contents = (0, import_smithy_client.map)({
3874
3609
  $metadata: deserializeMetadata(output)
@@ -3889,49 +3624,9 @@ var de_CreateDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
3889
3624
  Object.assign(contents, doc);
3890
3625
  return contents;
3891
3626
  }, "de_CreateDomainCommand");
3892
- var de_CreateDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
3893
- const parsedOutput = {
3894
- ...output,
3895
- body: await parseErrorBody(output.body, context)
3896
- };
3897
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3898
- switch (errorCode) {
3899
- case "AccessDeniedException":
3900
- case "com.amazonaws.datazone#AccessDeniedException":
3901
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3902
- case "ConflictException":
3903
- case "com.amazonaws.datazone#ConflictException":
3904
- throw await de_ConflictExceptionRes(parsedOutput, context);
3905
- case "InternalServerException":
3906
- case "com.amazonaws.datazone#InternalServerException":
3907
- throw await de_InternalServerExceptionRes(parsedOutput, context);
3908
- case "ResourceNotFoundException":
3909
- case "com.amazonaws.datazone#ResourceNotFoundException":
3910
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3911
- case "ServiceQuotaExceededException":
3912
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
3913
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
3914
- case "ThrottlingException":
3915
- case "com.amazonaws.datazone#ThrottlingException":
3916
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
3917
- case "UnauthorizedException":
3918
- case "com.amazonaws.datazone#UnauthorizedException":
3919
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3920
- case "ValidationException":
3921
- case "com.amazonaws.datazone#ValidationException":
3922
- throw await de_ValidationExceptionRes(parsedOutput, context);
3923
- default:
3924
- const parsedBody = parsedOutput.body;
3925
- return throwDefaultError({
3926
- output,
3927
- parsedBody,
3928
- errorCode
3929
- });
3930
- }
3931
- }, "de_CreateDomainCommandError");
3932
3627
  var de_CreateEnvironmentCommand = /* @__PURE__ */ __name(async (output, context) => {
3933
3628
  if (output.statusCode !== 201 && output.statusCode >= 300) {
3934
- return de_CreateEnvironmentCommandError(output, context);
3629
+ return de_CommandError(output, context);
3935
3630
  }
3936
3631
  const contents = (0, import_smithy_client.map)({
3937
3632
  $metadata: deserializeMetadata(output)
@@ -3963,46 +3658,9 @@ var de_CreateEnvironmentCommand = /* @__PURE__ */ __name(async (output, context)
3963
3658
  Object.assign(contents, doc);
3964
3659
  return contents;
3965
3660
  }, "de_CreateEnvironmentCommand");
3966
- var de_CreateEnvironmentCommandError = /* @__PURE__ */ __name(async (output, context) => {
3967
- const parsedOutput = {
3968
- ...output,
3969
- body: await parseErrorBody(output.body, context)
3970
- };
3971
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3972
- switch (errorCode) {
3973
- case "AccessDeniedException":
3974
- case "com.amazonaws.datazone#AccessDeniedException":
3975
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3976
- case "ConflictException":
3977
- case "com.amazonaws.datazone#ConflictException":
3978
- throw await de_ConflictExceptionRes(parsedOutput, context);
3979
- case "InternalServerException":
3980
- case "com.amazonaws.datazone#InternalServerException":
3981
- throw await de_InternalServerExceptionRes(parsedOutput, context);
3982
- case "ResourceNotFoundException":
3983
- case "com.amazonaws.datazone#ResourceNotFoundException":
3984
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3985
- case "ThrottlingException":
3986
- case "com.amazonaws.datazone#ThrottlingException":
3987
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
3988
- case "UnauthorizedException":
3989
- case "com.amazonaws.datazone#UnauthorizedException":
3990
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3991
- case "ValidationException":
3992
- case "com.amazonaws.datazone#ValidationException":
3993
- throw await de_ValidationExceptionRes(parsedOutput, context);
3994
- default:
3995
- const parsedBody = parsedOutput.body;
3996
- return throwDefaultError({
3997
- output,
3998
- parsedBody,
3999
- errorCode
4000
- });
4001
- }
4002
- }, "de_CreateEnvironmentCommandError");
4003
3661
  var de_CreateEnvironmentProfileCommand = /* @__PURE__ */ __name(async (output, context) => {
4004
3662
  if (output.statusCode !== 201 && output.statusCode >= 300) {
4005
- return de_CreateEnvironmentProfileCommandError(output, context);
3663
+ return de_CommandError(output, context);
4006
3664
  }
4007
3665
  const contents = (0, import_smithy_client.map)({
4008
3666
  $metadata: deserializeMetadata(output)
@@ -4025,49 +3683,9 @@ var de_CreateEnvironmentProfileCommand = /* @__PURE__ */ __name(async (output, c
4025
3683
  Object.assign(contents, doc);
4026
3684
  return contents;
4027
3685
  }, "de_CreateEnvironmentProfileCommand");
4028
- var de_CreateEnvironmentProfileCommandError = /* @__PURE__ */ __name(async (output, context) => {
4029
- const parsedOutput = {
4030
- ...output,
4031
- body: await parseErrorBody(output.body, context)
4032
- };
4033
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4034
- switch (errorCode) {
4035
- case "AccessDeniedException":
4036
- case "com.amazonaws.datazone#AccessDeniedException":
4037
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4038
- case "ConflictException":
4039
- case "com.amazonaws.datazone#ConflictException":
4040
- throw await de_ConflictExceptionRes(parsedOutput, context);
4041
- case "InternalServerException":
4042
- case "com.amazonaws.datazone#InternalServerException":
4043
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4044
- case "ResourceNotFoundException":
4045
- case "com.amazonaws.datazone#ResourceNotFoundException":
4046
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4047
- case "ServiceQuotaExceededException":
4048
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
4049
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
4050
- case "ThrottlingException":
4051
- case "com.amazonaws.datazone#ThrottlingException":
4052
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4053
- case "UnauthorizedException":
4054
- case "com.amazonaws.datazone#UnauthorizedException":
4055
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4056
- case "ValidationException":
4057
- case "com.amazonaws.datazone#ValidationException":
4058
- throw await de_ValidationExceptionRes(parsedOutput, context);
4059
- default:
4060
- const parsedBody = parsedOutput.body;
4061
- return throwDefaultError({
4062
- output,
4063
- parsedBody,
4064
- errorCode
4065
- });
4066
- }
4067
- }, "de_CreateEnvironmentProfileCommandError");
4068
3686
  var de_CreateFormTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
4069
3687
  if (output.statusCode !== 201 && output.statusCode >= 300) {
4070
- return de_CreateFormTypeCommandError(output, context);
3688
+ return de_CommandError(output, context);
4071
3689
  }
4072
3690
  const contents = (0, import_smithy_client.map)({
4073
3691
  $metadata: deserializeMetadata(output)
@@ -4085,46 +3703,9 @@ var de_CreateFormTypeCommand = /* @__PURE__ */ __name(async (output, context) =>
4085
3703
  Object.assign(contents, doc);
4086
3704
  return contents;
4087
3705
  }, "de_CreateFormTypeCommand");
4088
- var de_CreateFormTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
4089
- const parsedOutput = {
4090
- ...output,
4091
- body: await parseErrorBody(output.body, context)
4092
- };
4093
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4094
- switch (errorCode) {
4095
- case "AccessDeniedException":
4096
- case "com.amazonaws.datazone#AccessDeniedException":
4097
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4098
- case "ConflictException":
4099
- case "com.amazonaws.datazone#ConflictException":
4100
- throw await de_ConflictExceptionRes(parsedOutput, context);
4101
- case "InternalServerException":
4102
- case "com.amazonaws.datazone#InternalServerException":
4103
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4104
- case "ServiceQuotaExceededException":
4105
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
4106
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
4107
- case "ThrottlingException":
4108
- case "com.amazonaws.datazone#ThrottlingException":
4109
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4110
- case "UnauthorizedException":
4111
- case "com.amazonaws.datazone#UnauthorizedException":
4112
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4113
- case "ValidationException":
4114
- case "com.amazonaws.datazone#ValidationException":
4115
- throw await de_ValidationExceptionRes(parsedOutput, context);
4116
- default:
4117
- const parsedBody = parsedOutput.body;
4118
- return throwDefaultError({
4119
- output,
4120
- parsedBody,
4121
- errorCode
4122
- });
4123
- }
4124
- }, "de_CreateFormTypeCommandError");
4125
3706
  var de_CreateGlossaryCommand = /* @__PURE__ */ __name(async (output, context) => {
4126
3707
  if (output.statusCode !== 201 && output.statusCode >= 300) {
4127
- return de_CreateGlossaryCommandError(output, context);
3708
+ return de_CommandError(output, context);
4128
3709
  }
4129
3710
  const contents = (0, import_smithy_client.map)({
4130
3711
  $metadata: deserializeMetadata(output)
@@ -4141,46 +3722,9 @@ var de_CreateGlossaryCommand = /* @__PURE__ */ __name(async (output, context) =>
4141
3722
  Object.assign(contents, doc);
4142
3723
  return contents;
4143
3724
  }, "de_CreateGlossaryCommand");
4144
- var de_CreateGlossaryCommandError = /* @__PURE__ */ __name(async (output, context) => {
4145
- const parsedOutput = {
4146
- ...output,
4147
- body: await parseErrorBody(output.body, context)
4148
- };
4149
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4150
- switch (errorCode) {
4151
- case "AccessDeniedException":
4152
- case "com.amazonaws.datazone#AccessDeniedException":
4153
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4154
- case "ConflictException":
4155
- case "com.amazonaws.datazone#ConflictException":
4156
- throw await de_ConflictExceptionRes(parsedOutput, context);
4157
- case "InternalServerException":
4158
- case "com.amazonaws.datazone#InternalServerException":
4159
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4160
- case "ServiceQuotaExceededException":
4161
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
4162
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
4163
- case "ThrottlingException":
4164
- case "com.amazonaws.datazone#ThrottlingException":
4165
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4166
- case "UnauthorizedException":
4167
- case "com.amazonaws.datazone#UnauthorizedException":
4168
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4169
- case "ValidationException":
4170
- case "com.amazonaws.datazone#ValidationException":
4171
- throw await de_ValidationExceptionRes(parsedOutput, context);
4172
- default:
4173
- const parsedBody = parsedOutput.body;
4174
- return throwDefaultError({
4175
- output,
4176
- parsedBody,
4177
- errorCode
4178
- });
4179
- }
4180
- }, "de_CreateGlossaryCommandError");
4181
3725
  var de_CreateGlossaryTermCommand = /* @__PURE__ */ __name(async (output, context) => {
4182
3726
  if (output.statusCode !== 201 && output.statusCode >= 300) {
4183
- return de_CreateGlossaryTermCommandError(output, context);
3727
+ return de_CommandError(output, context);
4184
3728
  }
4185
3729
  const contents = (0, import_smithy_client.map)({
4186
3730
  $metadata: deserializeMetadata(output)
@@ -4199,49 +3743,9 @@ var de_CreateGlossaryTermCommand = /* @__PURE__ */ __name(async (output, context
4199
3743
  Object.assign(contents, doc);
4200
3744
  return contents;
4201
3745
  }, "de_CreateGlossaryTermCommand");
4202
- var de_CreateGlossaryTermCommandError = /* @__PURE__ */ __name(async (output, context) => {
4203
- const parsedOutput = {
4204
- ...output,
4205
- body: await parseErrorBody(output.body, context)
4206
- };
4207
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4208
- switch (errorCode) {
4209
- case "AccessDeniedException":
4210
- case "com.amazonaws.datazone#AccessDeniedException":
4211
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4212
- case "ConflictException":
4213
- case "com.amazonaws.datazone#ConflictException":
4214
- throw await de_ConflictExceptionRes(parsedOutput, context);
4215
- case "InternalServerException":
4216
- case "com.amazonaws.datazone#InternalServerException":
4217
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4218
- case "ResourceNotFoundException":
4219
- case "com.amazonaws.datazone#ResourceNotFoundException":
4220
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4221
- case "ServiceQuotaExceededException":
4222
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
4223
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
4224
- case "ThrottlingException":
4225
- case "com.amazonaws.datazone#ThrottlingException":
4226
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4227
- case "UnauthorizedException":
4228
- case "com.amazonaws.datazone#UnauthorizedException":
4229
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4230
- case "ValidationException":
4231
- case "com.amazonaws.datazone#ValidationException":
4232
- throw await de_ValidationExceptionRes(parsedOutput, context);
4233
- default:
4234
- const parsedBody = parsedOutput.body;
4235
- return throwDefaultError({
4236
- output,
4237
- parsedBody,
4238
- errorCode
4239
- });
4240
- }
4241
- }, "de_CreateGlossaryTermCommandError");
4242
3746
  var de_CreateGroupProfileCommand = /* @__PURE__ */ __name(async (output, context) => {
4243
3747
  if (output.statusCode !== 201 && output.statusCode >= 300) {
4244
- return de_CreateGroupProfileCommandError(output, context);
3748
+ return de_CommandError(output, context);
4245
3749
  }
4246
3750
  const contents = (0, import_smithy_client.map)({
4247
3751
  $metadata: deserializeMetadata(output)
@@ -4256,43 +3760,9 @@ var de_CreateGroupProfileCommand = /* @__PURE__ */ __name(async (output, context
4256
3760
  Object.assign(contents, doc);
4257
3761
  return contents;
4258
3762
  }, "de_CreateGroupProfileCommand");
4259
- var de_CreateGroupProfileCommandError = /* @__PURE__ */ __name(async (output, context) => {
4260
- const parsedOutput = {
4261
- ...output,
4262
- body: await parseErrorBody(output.body, context)
4263
- };
4264
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4265
- switch (errorCode) {
4266
- case "AccessDeniedException":
4267
- case "com.amazonaws.datazone#AccessDeniedException":
4268
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4269
- case "InternalServerException":
4270
- case "com.amazonaws.datazone#InternalServerException":
4271
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4272
- case "ResourceNotFoundException":
4273
- case "com.amazonaws.datazone#ResourceNotFoundException":
4274
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4275
- case "ThrottlingException":
4276
- case "com.amazonaws.datazone#ThrottlingException":
4277
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4278
- case "UnauthorizedException":
4279
- case "com.amazonaws.datazone#UnauthorizedException":
4280
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4281
- case "ValidationException":
4282
- case "com.amazonaws.datazone#ValidationException":
4283
- throw await de_ValidationExceptionRes(parsedOutput, context);
4284
- default:
4285
- const parsedBody = parsedOutput.body;
4286
- return throwDefaultError({
4287
- output,
4288
- parsedBody,
4289
- errorCode
4290
- });
4291
- }
4292
- }, "de_CreateGroupProfileCommandError");
4293
3763
  var de_CreateListingChangeSetCommand = /* @__PURE__ */ __name(async (output, context) => {
4294
3764
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4295
- return de_CreateListingChangeSetCommandError(output, context);
3765
+ return de_CommandError(output, context);
4296
3766
  }
4297
3767
  const contents = (0, import_smithy_client.map)({
4298
3768
  $metadata: deserializeMetadata(output)
@@ -4306,49 +3776,9 @@ var de_CreateListingChangeSetCommand = /* @__PURE__ */ __name(async (output, con
4306
3776
  Object.assign(contents, doc);
4307
3777
  return contents;
4308
3778
  }, "de_CreateListingChangeSetCommand");
4309
- var de_CreateListingChangeSetCommandError = /* @__PURE__ */ __name(async (output, context) => {
4310
- const parsedOutput = {
4311
- ...output,
4312
- body: await parseErrorBody(output.body, context)
4313
- };
4314
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4315
- switch (errorCode) {
4316
- case "AccessDeniedException":
4317
- case "com.amazonaws.datazone#AccessDeniedException":
4318
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4319
- case "ConflictException":
4320
- case "com.amazonaws.datazone#ConflictException":
4321
- throw await de_ConflictExceptionRes(parsedOutput, context);
4322
- case "InternalServerException":
4323
- case "com.amazonaws.datazone#InternalServerException":
4324
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4325
- case "ResourceNotFoundException":
4326
- case "com.amazonaws.datazone#ResourceNotFoundException":
4327
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4328
- case "ServiceQuotaExceededException":
4329
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
4330
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
4331
- case "ThrottlingException":
4332
- case "com.amazonaws.datazone#ThrottlingException":
4333
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4334
- case "UnauthorizedException":
4335
- case "com.amazonaws.datazone#UnauthorizedException":
4336
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4337
- case "ValidationException":
4338
- case "com.amazonaws.datazone#ValidationException":
4339
- throw await de_ValidationExceptionRes(parsedOutput, context);
4340
- default:
4341
- const parsedBody = parsedOutput.body;
4342
- return throwDefaultError({
4343
- output,
4344
- parsedBody,
4345
- errorCode
4346
- });
4347
- }
4348
- }, "de_CreateListingChangeSetCommandError");
4349
3779
  var de_CreateProjectCommand = /* @__PURE__ */ __name(async (output, context) => {
4350
3780
  if (output.statusCode !== 201 && output.statusCode >= 300) {
4351
- return de_CreateProjectCommandError(output, context);
3781
+ return de_CommandError(output, context);
4352
3782
  }
4353
3783
  const contents = (0, import_smithy_client.map)({
4354
3784
  $metadata: deserializeMetadata(output)
@@ -4369,49 +3799,9 @@ var de_CreateProjectCommand = /* @__PURE__ */ __name(async (output, context) =>
4369
3799
  Object.assign(contents, doc);
4370
3800
  return contents;
4371
3801
  }, "de_CreateProjectCommand");
4372
- var de_CreateProjectCommandError = /* @__PURE__ */ __name(async (output, context) => {
4373
- const parsedOutput = {
4374
- ...output,
4375
- body: await parseErrorBody(output.body, context)
4376
- };
4377
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4378
- switch (errorCode) {
4379
- case "AccessDeniedException":
4380
- case "com.amazonaws.datazone#AccessDeniedException":
4381
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4382
- case "ConflictException":
4383
- case "com.amazonaws.datazone#ConflictException":
4384
- throw await de_ConflictExceptionRes(parsedOutput, context);
4385
- case "InternalServerException":
4386
- case "com.amazonaws.datazone#InternalServerException":
4387
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4388
- case "ResourceNotFoundException":
4389
- case "com.amazonaws.datazone#ResourceNotFoundException":
4390
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4391
- case "ServiceQuotaExceededException":
4392
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
4393
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
4394
- case "ThrottlingException":
4395
- case "com.amazonaws.datazone#ThrottlingException":
4396
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4397
- case "UnauthorizedException":
4398
- case "com.amazonaws.datazone#UnauthorizedException":
4399
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4400
- case "ValidationException":
4401
- case "com.amazonaws.datazone#ValidationException":
4402
- throw await de_ValidationExceptionRes(parsedOutput, context);
4403
- default:
4404
- const parsedBody = parsedOutput.body;
4405
- return throwDefaultError({
4406
- output,
4407
- parsedBody,
4408
- errorCode
4409
- });
4410
- }
4411
- }, "de_CreateProjectCommandError");
4412
3802
  var de_CreateProjectMembershipCommand = /* @__PURE__ */ __name(async (output, context) => {
4413
3803
  if (output.statusCode !== 201 && output.statusCode >= 300) {
4414
- return de_CreateProjectMembershipCommandError(output, context);
3804
+ return de_CommandError(output, context);
4415
3805
  }
4416
3806
  const contents = (0, import_smithy_client.map)({
4417
3807
  $metadata: deserializeMetadata(output)
@@ -4419,43 +3809,9 @@ var de_CreateProjectMembershipCommand = /* @__PURE__ */ __name(async (output, co
4419
3809
  await (0, import_smithy_client.collectBody)(output.body, context);
4420
3810
  return contents;
4421
3811
  }, "de_CreateProjectMembershipCommand");
4422
- var de_CreateProjectMembershipCommandError = /* @__PURE__ */ __name(async (output, context) => {
4423
- const parsedOutput = {
4424
- ...output,
4425
- body: await parseErrorBody(output.body, context)
4426
- };
4427
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4428
- switch (errorCode) {
4429
- case "AccessDeniedException":
4430
- case "com.amazonaws.datazone#AccessDeniedException":
4431
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4432
- case "InternalServerException":
4433
- case "com.amazonaws.datazone#InternalServerException":
4434
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4435
- case "ResourceNotFoundException":
4436
- case "com.amazonaws.datazone#ResourceNotFoundException":
4437
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4438
- case "ThrottlingException":
4439
- case "com.amazonaws.datazone#ThrottlingException":
4440
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4441
- case "UnauthorizedException":
4442
- case "com.amazonaws.datazone#UnauthorizedException":
4443
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4444
- case "ValidationException":
4445
- case "com.amazonaws.datazone#ValidationException":
4446
- throw await de_ValidationExceptionRes(parsedOutput, context);
4447
- default:
4448
- const parsedBody = parsedOutput.body;
4449
- return throwDefaultError({
4450
- output,
4451
- parsedBody,
4452
- errorCode
4453
- });
4454
- }
4455
- }, "de_CreateProjectMembershipCommandError");
4456
3812
  var de_CreateSubscriptionGrantCommand = /* @__PURE__ */ __name(async (output, context) => {
4457
3813
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4458
- return de_CreateSubscriptionGrantCommandError(output, context);
3814
+ return de_CommandError(output, context);
4459
3815
  }
4460
3816
  const contents = (0, import_smithy_client.map)({
4461
3817
  $metadata: deserializeMetadata(output)
@@ -4477,46 +3833,9 @@ var de_CreateSubscriptionGrantCommand = /* @__PURE__ */ __name(async (output, co
4477
3833
  Object.assign(contents, doc);
4478
3834
  return contents;
4479
3835
  }, "de_CreateSubscriptionGrantCommand");
4480
- var de_CreateSubscriptionGrantCommandError = /* @__PURE__ */ __name(async (output, context) => {
4481
- const parsedOutput = {
4482
- ...output,
4483
- body: await parseErrorBody(output.body, context)
4484
- };
4485
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4486
- switch (errorCode) {
4487
- case "AccessDeniedException":
4488
- case "com.amazonaws.datazone#AccessDeniedException":
4489
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4490
- case "ConflictException":
4491
- case "com.amazonaws.datazone#ConflictException":
4492
- throw await de_ConflictExceptionRes(parsedOutput, context);
4493
- case "InternalServerException":
4494
- case "com.amazonaws.datazone#InternalServerException":
4495
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4496
- case "ResourceNotFoundException":
4497
- case "com.amazonaws.datazone#ResourceNotFoundException":
4498
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4499
- case "ThrottlingException":
4500
- case "com.amazonaws.datazone#ThrottlingException":
4501
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4502
- case "UnauthorizedException":
4503
- case "com.amazonaws.datazone#UnauthorizedException":
4504
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4505
- case "ValidationException":
4506
- case "com.amazonaws.datazone#ValidationException":
4507
- throw await de_ValidationExceptionRes(parsedOutput, context);
4508
- default:
4509
- const parsedBody = parsedOutput.body;
4510
- return throwDefaultError({
4511
- output,
4512
- parsedBody,
4513
- errorCode
4514
- });
4515
- }
4516
- }, "de_CreateSubscriptionGrantCommandError");
4517
3836
  var de_CreateSubscriptionRequestCommand = /* @__PURE__ */ __name(async (output, context) => {
4518
3837
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4519
- return de_CreateSubscriptionRequestCommandError(output, context);
3838
+ return de_CommandError(output, context);
4520
3839
  }
4521
3840
  const contents = (0, import_smithy_client.map)({
4522
3841
  $metadata: deserializeMetadata(output)
@@ -4539,46 +3858,9 @@ var de_CreateSubscriptionRequestCommand = /* @__PURE__ */ __name(async (output,
4539
3858
  Object.assign(contents, doc);
4540
3859
  return contents;
4541
3860
  }, "de_CreateSubscriptionRequestCommand");
4542
- var de_CreateSubscriptionRequestCommandError = /* @__PURE__ */ __name(async (output, context) => {
4543
- const parsedOutput = {
4544
- ...output,
4545
- body: await parseErrorBody(output.body, context)
4546
- };
4547
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4548
- switch (errorCode) {
4549
- case "AccessDeniedException":
4550
- case "com.amazonaws.datazone#AccessDeniedException":
4551
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4552
- case "ConflictException":
4553
- case "com.amazonaws.datazone#ConflictException":
4554
- throw await de_ConflictExceptionRes(parsedOutput, context);
4555
- case "InternalServerException":
4556
- case "com.amazonaws.datazone#InternalServerException":
4557
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4558
- case "ResourceNotFoundException":
4559
- case "com.amazonaws.datazone#ResourceNotFoundException":
4560
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4561
- case "ThrottlingException":
4562
- case "com.amazonaws.datazone#ThrottlingException":
4563
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4564
- case "UnauthorizedException":
4565
- case "com.amazonaws.datazone#UnauthorizedException":
4566
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4567
- case "ValidationException":
4568
- case "com.amazonaws.datazone#ValidationException":
4569
- throw await de_ValidationExceptionRes(parsedOutput, context);
4570
- default:
4571
- const parsedBody = parsedOutput.body;
4572
- return throwDefaultError({
4573
- output,
4574
- parsedBody,
4575
- errorCode
4576
- });
4577
- }
4578
- }, "de_CreateSubscriptionRequestCommandError");
4579
3861
  var de_CreateSubscriptionTargetCommand = /* @__PURE__ */ __name(async (output, context) => {
4580
3862
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4581
- return de_CreateSubscriptionTargetCommandError(output, context);
3863
+ return de_CommandError(output, context);
4582
3864
  }
4583
3865
  const contents = (0, import_smithy_client.map)({
4584
3866
  $metadata: deserializeMetadata(output)
@@ -4604,46 +3886,9 @@ var de_CreateSubscriptionTargetCommand = /* @__PURE__ */ __name(async (output, c
4604
3886
  Object.assign(contents, doc);
4605
3887
  return contents;
4606
3888
  }, "de_CreateSubscriptionTargetCommand");
4607
- var de_CreateSubscriptionTargetCommandError = /* @__PURE__ */ __name(async (output, context) => {
4608
- const parsedOutput = {
4609
- ...output,
4610
- body: await parseErrorBody(output.body, context)
4611
- };
4612
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4613
- switch (errorCode) {
4614
- case "AccessDeniedException":
4615
- case "com.amazonaws.datazone#AccessDeniedException":
4616
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4617
- case "ConflictException":
4618
- case "com.amazonaws.datazone#ConflictException":
4619
- throw await de_ConflictExceptionRes(parsedOutput, context);
4620
- case "InternalServerException":
4621
- case "com.amazonaws.datazone#InternalServerException":
4622
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4623
- case "ResourceNotFoundException":
4624
- case "com.amazonaws.datazone#ResourceNotFoundException":
4625
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4626
- case "ThrottlingException":
4627
- case "com.amazonaws.datazone#ThrottlingException":
4628
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4629
- case "UnauthorizedException":
4630
- case "com.amazonaws.datazone#UnauthorizedException":
4631
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4632
- case "ValidationException":
4633
- case "com.amazonaws.datazone#ValidationException":
4634
- throw await de_ValidationExceptionRes(parsedOutput, context);
4635
- default:
4636
- const parsedBody = parsedOutput.body;
4637
- return throwDefaultError({
4638
- output,
4639
- parsedBody,
4640
- errorCode
4641
- });
4642
- }
4643
- }, "de_CreateSubscriptionTargetCommandError");
4644
3889
  var de_CreateUserProfileCommand = /* @__PURE__ */ __name(async (output, context) => {
4645
3890
  if (output.statusCode !== 201 && output.statusCode >= 300) {
4646
- return de_CreateUserProfileCommandError(output, context);
3891
+ return de_CommandError(output, context);
4647
3892
  }
4648
3893
  const contents = (0, import_smithy_client.map)({
4649
3894
  $metadata: deserializeMetadata(output)
@@ -4659,43 +3904,9 @@ var de_CreateUserProfileCommand = /* @__PURE__ */ __name(async (output, context)
4659
3904
  Object.assign(contents, doc);
4660
3905
  return contents;
4661
3906
  }, "de_CreateUserProfileCommand");
4662
- var de_CreateUserProfileCommandError = /* @__PURE__ */ __name(async (output, context) => {
4663
- const parsedOutput = {
4664
- ...output,
4665
- body: await parseErrorBody(output.body, context)
4666
- };
4667
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4668
- switch (errorCode) {
4669
- case "AccessDeniedException":
4670
- case "com.amazonaws.datazone#AccessDeniedException":
4671
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4672
- case "InternalServerException":
4673
- case "com.amazonaws.datazone#InternalServerException":
4674
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4675
- case "ResourceNotFoundException":
4676
- case "com.amazonaws.datazone#ResourceNotFoundException":
4677
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4678
- case "ThrottlingException":
4679
- case "com.amazonaws.datazone#ThrottlingException":
4680
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4681
- case "UnauthorizedException":
4682
- case "com.amazonaws.datazone#UnauthorizedException":
4683
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4684
- case "ValidationException":
4685
- case "com.amazonaws.datazone#ValidationException":
4686
- throw await de_ValidationExceptionRes(parsedOutput, context);
4687
- default:
4688
- const parsedBody = parsedOutput.body;
4689
- return throwDefaultError({
4690
- output,
4691
- parsedBody,
4692
- errorCode
4693
- });
4694
- }
4695
- }, "de_CreateUserProfileCommandError");
4696
3907
  var de_DeleteAssetCommand = /* @__PURE__ */ __name(async (output, context) => {
4697
3908
  if (output.statusCode !== 204 && output.statusCode >= 300) {
4698
- return de_DeleteAssetCommandError(output, context);
3909
+ return de_CommandError(output, context);
4699
3910
  }
4700
3911
  const contents = (0, import_smithy_client.map)({
4701
3912
  $metadata: deserializeMetadata(output)
@@ -4703,43 +3914,9 @@ var de_DeleteAssetCommand = /* @__PURE__ */ __name(async (output, context) => {
4703
3914
  await (0, import_smithy_client.collectBody)(output.body, context);
4704
3915
  return contents;
4705
3916
  }, "de_DeleteAssetCommand");
4706
- var de_DeleteAssetCommandError = /* @__PURE__ */ __name(async (output, context) => {
4707
- const parsedOutput = {
4708
- ...output,
4709
- body: await parseErrorBody(output.body, context)
4710
- };
4711
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4712
- switch (errorCode) {
4713
- case "AccessDeniedException":
4714
- case "com.amazonaws.datazone#AccessDeniedException":
4715
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4716
- case "InternalServerException":
4717
- case "com.amazonaws.datazone#InternalServerException":
4718
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4719
- case "ResourceNotFoundException":
4720
- case "com.amazonaws.datazone#ResourceNotFoundException":
4721
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4722
- case "ThrottlingException":
4723
- case "com.amazonaws.datazone#ThrottlingException":
4724
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4725
- case "UnauthorizedException":
4726
- case "com.amazonaws.datazone#UnauthorizedException":
4727
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4728
- case "ValidationException":
4729
- case "com.amazonaws.datazone#ValidationException":
4730
- throw await de_ValidationExceptionRes(parsedOutput, context);
4731
- default:
4732
- const parsedBody = parsedOutput.body;
4733
- return throwDefaultError({
4734
- output,
4735
- parsedBody,
4736
- errorCode
4737
- });
4738
- }
4739
- }, "de_DeleteAssetCommandError");
4740
3917
  var de_DeleteAssetTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
4741
3918
  if (output.statusCode !== 204 && output.statusCode >= 300) {
4742
- return de_DeleteAssetTypeCommandError(output, context);
3919
+ return de_CommandError(output, context);
4743
3920
  }
4744
3921
  const contents = (0, import_smithy_client.map)({
4745
3922
  $metadata: deserializeMetadata(output)
@@ -4747,46 +3924,9 @@ var de_DeleteAssetTypeCommand = /* @__PURE__ */ __name(async (output, context) =
4747
3924
  await (0, import_smithy_client.collectBody)(output.body, context);
4748
3925
  return contents;
4749
3926
  }, "de_DeleteAssetTypeCommand");
4750
- var de_DeleteAssetTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
4751
- const parsedOutput = {
4752
- ...output,
4753
- body: await parseErrorBody(output.body, context)
4754
- };
4755
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4756
- switch (errorCode) {
4757
- case "AccessDeniedException":
4758
- case "com.amazonaws.datazone#AccessDeniedException":
4759
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4760
- case "ConflictException":
4761
- case "com.amazonaws.datazone#ConflictException":
4762
- throw await de_ConflictExceptionRes(parsedOutput, context);
4763
- case "InternalServerException":
4764
- case "com.amazonaws.datazone#InternalServerException":
4765
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4766
- case "ResourceNotFoundException":
4767
- case "com.amazonaws.datazone#ResourceNotFoundException":
4768
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4769
- case "ThrottlingException":
4770
- case "com.amazonaws.datazone#ThrottlingException":
4771
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4772
- case "UnauthorizedException":
4773
- case "com.amazonaws.datazone#UnauthorizedException":
4774
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4775
- case "ValidationException":
4776
- case "com.amazonaws.datazone#ValidationException":
4777
- throw await de_ValidationExceptionRes(parsedOutput, context);
4778
- default:
4779
- const parsedBody = parsedOutput.body;
4780
- return throwDefaultError({
4781
- output,
4782
- parsedBody,
4783
- errorCode
4784
- });
4785
- }
4786
- }, "de_DeleteAssetTypeCommandError");
4787
3927
  var de_DeleteDataSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
4788
3928
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4789
- return de_DeleteDataSourceCommandError(output, context);
3929
+ return de_CommandError(output, context);
4790
3930
  }
4791
3931
  const contents = (0, import_smithy_client.map)({
4792
3932
  $metadata: deserializeMetadata(output)
@@ -4816,49 +3956,9 @@ var de_DeleteDataSourceCommand = /* @__PURE__ */ __name(async (output, context)
4816
3956
  Object.assign(contents, doc);
4817
3957
  return contents;
4818
3958
  }, "de_DeleteDataSourceCommand");
4819
- var de_DeleteDataSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
4820
- const parsedOutput = {
4821
- ...output,
4822
- body: await parseErrorBody(output.body, context)
4823
- };
4824
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4825
- switch (errorCode) {
4826
- case "AccessDeniedException":
4827
- case "com.amazonaws.datazone#AccessDeniedException":
4828
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4829
- case "ConflictException":
4830
- case "com.amazonaws.datazone#ConflictException":
4831
- throw await de_ConflictExceptionRes(parsedOutput, context);
4832
- case "InternalServerException":
4833
- case "com.amazonaws.datazone#InternalServerException":
4834
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4835
- case "ResourceNotFoundException":
4836
- case "com.amazonaws.datazone#ResourceNotFoundException":
4837
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4838
- case "ServiceQuotaExceededException":
4839
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
4840
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
4841
- case "ThrottlingException":
4842
- case "com.amazonaws.datazone#ThrottlingException":
4843
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4844
- case "UnauthorizedException":
4845
- case "com.amazonaws.datazone#UnauthorizedException":
4846
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4847
- case "ValidationException":
4848
- case "com.amazonaws.datazone#ValidationException":
4849
- throw await de_ValidationExceptionRes(parsedOutput, context);
4850
- default:
4851
- const parsedBody = parsedOutput.body;
4852
- return throwDefaultError({
4853
- output,
4854
- parsedBody,
4855
- errorCode
4856
- });
4857
- }
4858
- }, "de_DeleteDataSourceCommandError");
4859
3959
  var de_DeleteDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
4860
3960
  if (output.statusCode !== 202 && output.statusCode >= 300) {
4861
- return de_DeleteDomainCommandError(output, context);
3961
+ return de_CommandError(output, context);
4862
3962
  }
4863
3963
  const contents = (0, import_smithy_client.map)({
4864
3964
  $metadata: deserializeMetadata(output)
@@ -4870,46 +3970,9 @@ var de_DeleteDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
4870
3970
  Object.assign(contents, doc);
4871
3971
  return contents;
4872
3972
  }, "de_DeleteDomainCommand");
4873
- var de_DeleteDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
4874
- const parsedOutput = {
4875
- ...output,
4876
- body: await parseErrorBody(output.body, context)
4877
- };
4878
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4879
- switch (errorCode) {
4880
- case "AccessDeniedException":
4881
- case "com.amazonaws.datazone#AccessDeniedException":
4882
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4883
- case "ConflictException":
4884
- case "com.amazonaws.datazone#ConflictException":
4885
- throw await de_ConflictExceptionRes(parsedOutput, context);
4886
- case "InternalServerException":
4887
- case "com.amazonaws.datazone#InternalServerException":
4888
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4889
- case "ResourceNotFoundException":
4890
- case "com.amazonaws.datazone#ResourceNotFoundException":
4891
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4892
- case "ThrottlingException":
4893
- case "com.amazonaws.datazone#ThrottlingException":
4894
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4895
- case "UnauthorizedException":
4896
- case "com.amazonaws.datazone#UnauthorizedException":
4897
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4898
- case "ValidationException":
4899
- case "com.amazonaws.datazone#ValidationException":
4900
- throw await de_ValidationExceptionRes(parsedOutput, context);
4901
- default:
4902
- const parsedBody = parsedOutput.body;
4903
- return throwDefaultError({
4904
- output,
4905
- parsedBody,
4906
- errorCode
4907
- });
4908
- }
4909
- }, "de_DeleteDomainCommandError");
4910
3973
  var de_DeleteEnvironmentCommand = /* @__PURE__ */ __name(async (output, context) => {
4911
3974
  if (output.statusCode !== 204 && output.statusCode >= 300) {
4912
- return de_DeleteEnvironmentCommandError(output, context);
3975
+ return de_CommandError(output, context);
4913
3976
  }
4914
3977
  const contents = (0, import_smithy_client.map)({
4915
3978
  $metadata: deserializeMetadata(output)
@@ -4917,43 +3980,9 @@ var de_DeleteEnvironmentCommand = /* @__PURE__ */ __name(async (output, context)
4917
3980
  await (0, import_smithy_client.collectBody)(output.body, context);
4918
3981
  return contents;
4919
3982
  }, "de_DeleteEnvironmentCommand");
4920
- var de_DeleteEnvironmentCommandError = /* @__PURE__ */ __name(async (output, context) => {
4921
- const parsedOutput = {
4922
- ...output,
4923
- body: await parseErrorBody(output.body, context)
4924
- };
4925
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4926
- switch (errorCode) {
4927
- case "AccessDeniedException":
4928
- case "com.amazonaws.datazone#AccessDeniedException":
4929
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4930
- case "InternalServerException":
4931
- case "com.amazonaws.datazone#InternalServerException":
4932
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4933
- case "ResourceNotFoundException":
4934
- case "com.amazonaws.datazone#ResourceNotFoundException":
4935
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4936
- case "ThrottlingException":
4937
- case "com.amazonaws.datazone#ThrottlingException":
4938
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4939
- case "UnauthorizedException":
4940
- case "com.amazonaws.datazone#UnauthorizedException":
4941
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4942
- case "ValidationException":
4943
- case "com.amazonaws.datazone#ValidationException":
4944
- throw await de_ValidationExceptionRes(parsedOutput, context);
4945
- default:
4946
- const parsedBody = parsedOutput.body;
4947
- return throwDefaultError({
4948
- output,
4949
- parsedBody,
4950
- errorCode
4951
- });
4952
- }
4953
- }, "de_DeleteEnvironmentCommandError");
4954
3983
  var de_DeleteEnvironmentBlueprintConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
4955
3984
  if (output.statusCode !== 204 && output.statusCode >= 300) {
4956
- return de_DeleteEnvironmentBlueprintConfigurationCommandError(output, context);
3985
+ return de_CommandError(output, context);
4957
3986
  }
4958
3987
  const contents = (0, import_smithy_client.map)({
4959
3988
  $metadata: deserializeMetadata(output)
@@ -4961,40 +3990,9 @@ var de_DeleteEnvironmentBlueprintConfigurationCommand = /* @__PURE__ */ __name(a
4961
3990
  await (0, import_smithy_client.collectBody)(output.body, context);
4962
3991
  return contents;
4963
3992
  }, "de_DeleteEnvironmentBlueprintConfigurationCommand");
4964
- var de_DeleteEnvironmentBlueprintConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
4965
- const parsedOutput = {
4966
- ...output,
4967
- body: await parseErrorBody(output.body, context)
4968
- };
4969
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4970
- switch (errorCode) {
4971
- case "AccessDeniedException":
4972
- case "com.amazonaws.datazone#AccessDeniedException":
4973
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4974
- case "InternalServerException":
4975
- case "com.amazonaws.datazone#InternalServerException":
4976
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4977
- case "ThrottlingException":
4978
- case "com.amazonaws.datazone#ThrottlingException":
4979
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4980
- case "UnauthorizedException":
4981
- case "com.amazonaws.datazone#UnauthorizedException":
4982
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
4983
- case "ValidationException":
4984
- case "com.amazonaws.datazone#ValidationException":
4985
- throw await de_ValidationExceptionRes(parsedOutput, context);
4986
- default:
4987
- const parsedBody = parsedOutput.body;
4988
- return throwDefaultError({
4989
- output,
4990
- parsedBody,
4991
- errorCode
4992
- });
4993
- }
4994
- }, "de_DeleteEnvironmentBlueprintConfigurationCommandError");
4995
3993
  var de_DeleteEnvironmentProfileCommand = /* @__PURE__ */ __name(async (output, context) => {
4996
3994
  if (output.statusCode !== 204 && output.statusCode >= 300) {
4997
- return de_DeleteEnvironmentProfileCommandError(output, context);
3995
+ return de_CommandError(output, context);
4998
3996
  }
4999
3997
  const contents = (0, import_smithy_client.map)({
5000
3998
  $metadata: deserializeMetadata(output)
@@ -5002,43 +4000,9 @@ var de_DeleteEnvironmentProfileCommand = /* @__PURE__ */ __name(async (output, c
5002
4000
  await (0, import_smithy_client.collectBody)(output.body, context);
5003
4001
  return contents;
5004
4002
  }, "de_DeleteEnvironmentProfileCommand");
5005
- var de_DeleteEnvironmentProfileCommandError = /* @__PURE__ */ __name(async (output, context) => {
5006
- const parsedOutput = {
5007
- ...output,
5008
- body: await parseErrorBody(output.body, context)
5009
- };
5010
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5011
- switch (errorCode) {
5012
- case "AccessDeniedException":
5013
- case "com.amazonaws.datazone#AccessDeniedException":
5014
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5015
- case "InternalServerException":
5016
- case "com.amazonaws.datazone#InternalServerException":
5017
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5018
- case "ResourceNotFoundException":
5019
- case "com.amazonaws.datazone#ResourceNotFoundException":
5020
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5021
- case "ThrottlingException":
5022
- case "com.amazonaws.datazone#ThrottlingException":
5023
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5024
- case "UnauthorizedException":
5025
- case "com.amazonaws.datazone#UnauthorizedException":
5026
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5027
- case "ValidationException":
5028
- case "com.amazonaws.datazone#ValidationException":
5029
- throw await de_ValidationExceptionRes(parsedOutput, context);
5030
- default:
5031
- const parsedBody = parsedOutput.body;
5032
- return throwDefaultError({
5033
- output,
5034
- parsedBody,
5035
- errorCode
5036
- });
5037
- }
5038
- }, "de_DeleteEnvironmentProfileCommandError");
5039
4003
  var de_DeleteFormTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
5040
4004
  if (output.statusCode !== 204 && output.statusCode >= 300) {
5041
- return de_DeleteFormTypeCommandError(output, context);
4005
+ return de_CommandError(output, context);
5042
4006
  }
5043
4007
  const contents = (0, import_smithy_client.map)({
5044
4008
  $metadata: deserializeMetadata(output)
@@ -5046,46 +4010,9 @@ var de_DeleteFormTypeCommand = /* @__PURE__ */ __name(async (output, context) =>
5046
4010
  await (0, import_smithy_client.collectBody)(output.body, context);
5047
4011
  return contents;
5048
4012
  }, "de_DeleteFormTypeCommand");
5049
- var de_DeleteFormTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
5050
- const parsedOutput = {
5051
- ...output,
5052
- body: await parseErrorBody(output.body, context)
5053
- };
5054
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5055
- switch (errorCode) {
5056
- case "AccessDeniedException":
5057
- case "com.amazonaws.datazone#AccessDeniedException":
5058
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5059
- case "ConflictException":
5060
- case "com.amazonaws.datazone#ConflictException":
5061
- throw await de_ConflictExceptionRes(parsedOutput, context);
5062
- case "InternalServerException":
5063
- case "com.amazonaws.datazone#InternalServerException":
5064
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5065
- case "ResourceNotFoundException":
5066
- case "com.amazonaws.datazone#ResourceNotFoundException":
5067
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5068
- case "ThrottlingException":
5069
- case "com.amazonaws.datazone#ThrottlingException":
5070
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5071
- case "UnauthorizedException":
5072
- case "com.amazonaws.datazone#UnauthorizedException":
5073
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5074
- case "ValidationException":
5075
- case "com.amazonaws.datazone#ValidationException":
5076
- throw await de_ValidationExceptionRes(parsedOutput, context);
5077
- default:
5078
- const parsedBody = parsedOutput.body;
5079
- return throwDefaultError({
5080
- output,
5081
- parsedBody,
5082
- errorCode
5083
- });
5084
- }
5085
- }, "de_DeleteFormTypeCommandError");
5086
4013
  var de_DeleteGlossaryCommand = /* @__PURE__ */ __name(async (output, context) => {
5087
4014
  if (output.statusCode !== 204 && output.statusCode >= 300) {
5088
- return de_DeleteGlossaryCommandError(output, context);
4015
+ return de_CommandError(output, context);
5089
4016
  }
5090
4017
  const contents = (0, import_smithy_client.map)({
5091
4018
  $metadata: deserializeMetadata(output)
@@ -5093,46 +4020,9 @@ var de_DeleteGlossaryCommand = /* @__PURE__ */ __name(async (output, context) =>
5093
4020
  await (0, import_smithy_client.collectBody)(output.body, context);
5094
4021
  return contents;
5095
4022
  }, "de_DeleteGlossaryCommand");
5096
- var de_DeleteGlossaryCommandError = /* @__PURE__ */ __name(async (output, context) => {
5097
- const parsedOutput = {
5098
- ...output,
5099
- body: await parseErrorBody(output.body, context)
5100
- };
5101
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5102
- switch (errorCode) {
5103
- case "AccessDeniedException":
5104
- case "com.amazonaws.datazone#AccessDeniedException":
5105
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5106
- case "ConflictException":
5107
- case "com.amazonaws.datazone#ConflictException":
5108
- throw await de_ConflictExceptionRes(parsedOutput, context);
5109
- case "InternalServerException":
5110
- case "com.amazonaws.datazone#InternalServerException":
5111
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5112
- case "ResourceNotFoundException":
5113
- case "com.amazonaws.datazone#ResourceNotFoundException":
5114
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5115
- case "ThrottlingException":
5116
- case "com.amazonaws.datazone#ThrottlingException":
5117
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5118
- case "UnauthorizedException":
5119
- case "com.amazonaws.datazone#UnauthorizedException":
5120
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5121
- case "ValidationException":
5122
- case "com.amazonaws.datazone#ValidationException":
5123
- throw await de_ValidationExceptionRes(parsedOutput, context);
5124
- default:
5125
- const parsedBody = parsedOutput.body;
5126
- return throwDefaultError({
5127
- output,
5128
- parsedBody,
5129
- errorCode
5130
- });
5131
- }
5132
- }, "de_DeleteGlossaryCommandError");
5133
4023
  var de_DeleteGlossaryTermCommand = /* @__PURE__ */ __name(async (output, context) => {
5134
4024
  if (output.statusCode !== 204 && output.statusCode >= 300) {
5135
- return de_DeleteGlossaryTermCommandError(output, context);
4025
+ return de_CommandError(output, context);
5136
4026
  }
5137
4027
  const contents = (0, import_smithy_client.map)({
5138
4028
  $metadata: deserializeMetadata(output)
@@ -5140,46 +4030,9 @@ var de_DeleteGlossaryTermCommand = /* @__PURE__ */ __name(async (output, context
5140
4030
  await (0, import_smithy_client.collectBody)(output.body, context);
5141
4031
  return contents;
5142
4032
  }, "de_DeleteGlossaryTermCommand");
5143
- var de_DeleteGlossaryTermCommandError = /* @__PURE__ */ __name(async (output, context) => {
5144
- const parsedOutput = {
5145
- ...output,
5146
- body: await parseErrorBody(output.body, context)
5147
- };
5148
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5149
- switch (errorCode) {
5150
- case "AccessDeniedException":
5151
- case "com.amazonaws.datazone#AccessDeniedException":
5152
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5153
- case "ConflictException":
5154
- case "com.amazonaws.datazone#ConflictException":
5155
- throw await de_ConflictExceptionRes(parsedOutput, context);
5156
- case "InternalServerException":
5157
- case "com.amazonaws.datazone#InternalServerException":
5158
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5159
- case "ResourceNotFoundException":
5160
- case "com.amazonaws.datazone#ResourceNotFoundException":
5161
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5162
- case "ThrottlingException":
5163
- case "com.amazonaws.datazone#ThrottlingException":
5164
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5165
- case "UnauthorizedException":
5166
- case "com.amazonaws.datazone#UnauthorizedException":
5167
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5168
- case "ValidationException":
5169
- case "com.amazonaws.datazone#ValidationException":
5170
- throw await de_ValidationExceptionRes(parsedOutput, context);
5171
- default:
5172
- const parsedBody = parsedOutput.body;
5173
- return throwDefaultError({
5174
- output,
5175
- parsedBody,
5176
- errorCode
5177
- });
5178
- }
5179
- }, "de_DeleteGlossaryTermCommandError");
5180
4033
  var de_DeleteListingCommand = /* @__PURE__ */ __name(async (output, context) => {
5181
4034
  if (output.statusCode !== 204 && output.statusCode >= 300) {
5182
- return de_DeleteListingCommandError(output, context);
4035
+ return de_CommandError(output, context);
5183
4036
  }
5184
4037
  const contents = (0, import_smithy_client.map)({
5185
4038
  $metadata: deserializeMetadata(output)
@@ -5187,46 +4040,9 @@ var de_DeleteListingCommand = /* @__PURE__ */ __name(async (output, context) =>
5187
4040
  await (0, import_smithy_client.collectBody)(output.body, context);
5188
4041
  return contents;
5189
4042
  }, "de_DeleteListingCommand");
5190
- var de_DeleteListingCommandError = /* @__PURE__ */ __name(async (output, context) => {
5191
- const parsedOutput = {
5192
- ...output,
5193
- body: await parseErrorBody(output.body, context)
5194
- };
5195
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5196
- switch (errorCode) {
5197
- case "AccessDeniedException":
5198
- case "com.amazonaws.datazone#AccessDeniedException":
5199
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5200
- case "ConflictException":
5201
- case "com.amazonaws.datazone#ConflictException":
5202
- throw await de_ConflictExceptionRes(parsedOutput, context);
5203
- case "InternalServerException":
5204
- case "com.amazonaws.datazone#InternalServerException":
5205
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5206
- case "ResourceNotFoundException":
5207
- case "com.amazonaws.datazone#ResourceNotFoundException":
5208
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5209
- case "ThrottlingException":
5210
- case "com.amazonaws.datazone#ThrottlingException":
5211
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5212
- case "UnauthorizedException":
5213
- case "com.amazonaws.datazone#UnauthorizedException":
5214
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5215
- case "ValidationException":
5216
- case "com.amazonaws.datazone#ValidationException":
5217
- throw await de_ValidationExceptionRes(parsedOutput, context);
5218
- default:
5219
- const parsedBody = parsedOutput.body;
5220
- return throwDefaultError({
5221
- output,
5222
- parsedBody,
5223
- errorCode
5224
- });
5225
- }
5226
- }, "de_DeleteListingCommandError");
5227
4043
  var de_DeleteProjectCommand = /* @__PURE__ */ __name(async (output, context) => {
5228
4044
  if (output.statusCode !== 204 && output.statusCode >= 300) {
5229
- return de_DeleteProjectCommandError(output, context);
4045
+ return de_CommandError(output, context);
5230
4046
  }
5231
4047
  const contents = (0, import_smithy_client.map)({
5232
4048
  $metadata: deserializeMetadata(output)
@@ -5234,43 +4050,9 @@ var de_DeleteProjectCommand = /* @__PURE__ */ __name(async (output, context) =>
5234
4050
  await (0, import_smithy_client.collectBody)(output.body, context);
5235
4051
  return contents;
5236
4052
  }, "de_DeleteProjectCommand");
5237
- var de_DeleteProjectCommandError = /* @__PURE__ */ __name(async (output, context) => {
5238
- const parsedOutput = {
5239
- ...output,
5240
- body: await parseErrorBody(output.body, context)
5241
- };
5242
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5243
- switch (errorCode) {
5244
- case "AccessDeniedException":
5245
- case "com.amazonaws.datazone#AccessDeniedException":
5246
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5247
- case "InternalServerException":
5248
- case "com.amazonaws.datazone#InternalServerException":
5249
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5250
- case "ResourceNotFoundException":
5251
- case "com.amazonaws.datazone#ResourceNotFoundException":
5252
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5253
- case "ThrottlingException":
5254
- case "com.amazonaws.datazone#ThrottlingException":
5255
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5256
- case "UnauthorizedException":
5257
- case "com.amazonaws.datazone#UnauthorizedException":
5258
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5259
- case "ValidationException":
5260
- case "com.amazonaws.datazone#ValidationException":
5261
- throw await de_ValidationExceptionRes(parsedOutput, context);
5262
- default:
5263
- const parsedBody = parsedOutput.body;
5264
- return throwDefaultError({
5265
- output,
5266
- parsedBody,
5267
- errorCode
5268
- });
5269
- }
5270
- }, "de_DeleteProjectCommandError");
5271
4053
  var de_DeleteProjectMembershipCommand = /* @__PURE__ */ __name(async (output, context) => {
5272
4054
  if (output.statusCode !== 204 && output.statusCode >= 300) {
5273
- return de_DeleteProjectMembershipCommandError(output, context);
4055
+ return de_CommandError(output, context);
5274
4056
  }
5275
4057
  const contents = (0, import_smithy_client.map)({
5276
4058
  $metadata: deserializeMetadata(output)
@@ -5278,46 +4060,9 @@ var de_DeleteProjectMembershipCommand = /* @__PURE__ */ __name(async (output, co
5278
4060
  await (0, import_smithy_client.collectBody)(output.body, context);
5279
4061
  return contents;
5280
4062
  }, "de_DeleteProjectMembershipCommand");
5281
- var de_DeleteProjectMembershipCommandError = /* @__PURE__ */ __name(async (output, context) => {
5282
- const parsedOutput = {
5283
- ...output,
5284
- body: await parseErrorBody(output.body, context)
5285
- };
5286
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5287
- switch (errorCode) {
5288
- case "AccessDeniedException":
5289
- case "com.amazonaws.datazone#AccessDeniedException":
5290
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5291
- case "InternalServerException":
5292
- case "com.amazonaws.datazone#InternalServerException":
5293
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5294
- case "ResourceNotFoundException":
5295
- case "com.amazonaws.datazone#ResourceNotFoundException":
5296
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5297
- case "ServiceQuotaExceededException":
5298
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
5299
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
5300
- case "ThrottlingException":
5301
- case "com.amazonaws.datazone#ThrottlingException":
5302
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5303
- case "UnauthorizedException":
5304
- case "com.amazonaws.datazone#UnauthorizedException":
5305
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5306
- case "ValidationException":
5307
- case "com.amazonaws.datazone#ValidationException":
5308
- throw await de_ValidationExceptionRes(parsedOutput, context);
5309
- default:
5310
- const parsedBody = parsedOutput.body;
5311
- return throwDefaultError({
5312
- output,
5313
- parsedBody,
5314
- errorCode
5315
- });
5316
- }
5317
- }, "de_DeleteProjectMembershipCommandError");
5318
4063
  var de_DeleteSubscriptionGrantCommand = /* @__PURE__ */ __name(async (output, context) => {
5319
4064
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5320
- return de_DeleteSubscriptionGrantCommandError(output, context);
4065
+ return de_CommandError(output, context);
5321
4066
  }
5322
4067
  const contents = (0, import_smithy_client.map)({
5323
4068
  $metadata: deserializeMetadata(output)
@@ -5339,46 +4084,9 @@ var de_DeleteSubscriptionGrantCommand = /* @__PURE__ */ __name(async (output, co
5339
4084
  Object.assign(contents, doc);
5340
4085
  return contents;
5341
4086
  }, "de_DeleteSubscriptionGrantCommand");
5342
- var de_DeleteSubscriptionGrantCommandError = /* @__PURE__ */ __name(async (output, context) => {
5343
- const parsedOutput = {
5344
- ...output,
5345
- body: await parseErrorBody(output.body, context)
5346
- };
5347
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5348
- switch (errorCode) {
5349
- case "AccessDeniedException":
5350
- case "com.amazonaws.datazone#AccessDeniedException":
5351
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5352
- case "ConflictException":
5353
- case "com.amazonaws.datazone#ConflictException":
5354
- throw await de_ConflictExceptionRes(parsedOutput, context);
5355
- case "InternalServerException":
5356
- case "com.amazonaws.datazone#InternalServerException":
5357
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5358
- case "ResourceNotFoundException":
5359
- case "com.amazonaws.datazone#ResourceNotFoundException":
5360
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5361
- case "ThrottlingException":
5362
- case "com.amazonaws.datazone#ThrottlingException":
5363
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5364
- case "UnauthorizedException":
5365
- case "com.amazonaws.datazone#UnauthorizedException":
5366
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5367
- case "ValidationException":
5368
- case "com.amazonaws.datazone#ValidationException":
5369
- throw await de_ValidationExceptionRes(parsedOutput, context);
5370
- default:
5371
- const parsedBody = parsedOutput.body;
5372
- return throwDefaultError({
5373
- output,
5374
- parsedBody,
5375
- errorCode
5376
- });
5377
- }
5378
- }, "de_DeleteSubscriptionGrantCommandError");
5379
4087
  var de_DeleteSubscriptionRequestCommand = /* @__PURE__ */ __name(async (output, context) => {
5380
4088
  if (output.statusCode !== 204 && output.statusCode >= 300) {
5381
- return de_DeleteSubscriptionRequestCommandError(output, context);
4089
+ return de_CommandError(output, context);
5382
4090
  }
5383
4091
  const contents = (0, import_smithy_client.map)({
5384
4092
  $metadata: deserializeMetadata(output)
@@ -5386,46 +4094,9 @@ var de_DeleteSubscriptionRequestCommand = /* @__PURE__ */ __name(async (output,
5386
4094
  await (0, import_smithy_client.collectBody)(output.body, context);
5387
4095
  return contents;
5388
4096
  }, "de_DeleteSubscriptionRequestCommand");
5389
- var de_DeleteSubscriptionRequestCommandError = /* @__PURE__ */ __name(async (output, context) => {
5390
- const parsedOutput = {
5391
- ...output,
5392
- body: await parseErrorBody(output.body, context)
5393
- };
5394
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5395
- switch (errorCode) {
5396
- case "AccessDeniedException":
5397
- case "com.amazonaws.datazone#AccessDeniedException":
5398
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5399
- case "ConflictException":
5400
- case "com.amazonaws.datazone#ConflictException":
5401
- throw await de_ConflictExceptionRes(parsedOutput, context);
5402
- case "InternalServerException":
5403
- case "com.amazonaws.datazone#InternalServerException":
5404
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5405
- case "ResourceNotFoundException":
5406
- case "com.amazonaws.datazone#ResourceNotFoundException":
5407
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5408
- case "ThrottlingException":
5409
- case "com.amazonaws.datazone#ThrottlingException":
5410
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5411
- case "UnauthorizedException":
5412
- case "com.amazonaws.datazone#UnauthorizedException":
5413
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5414
- case "ValidationException":
5415
- case "com.amazonaws.datazone#ValidationException":
5416
- throw await de_ValidationExceptionRes(parsedOutput, context);
5417
- default:
5418
- const parsedBody = parsedOutput.body;
5419
- return throwDefaultError({
5420
- output,
5421
- parsedBody,
5422
- errorCode
5423
- });
5424
- }
5425
- }, "de_DeleteSubscriptionRequestCommandError");
5426
4097
  var de_DeleteSubscriptionTargetCommand = /* @__PURE__ */ __name(async (output, context) => {
5427
4098
  if (output.statusCode !== 204 && output.statusCode >= 300) {
5428
- return de_DeleteSubscriptionTargetCommandError(output, context);
4099
+ return de_CommandError(output, context);
5429
4100
  }
5430
4101
  const contents = (0, import_smithy_client.map)({
5431
4102
  $metadata: deserializeMetadata(output)
@@ -5433,46 +4104,9 @@ var de_DeleteSubscriptionTargetCommand = /* @__PURE__ */ __name(async (output, c
5433
4104
  await (0, import_smithy_client.collectBody)(output.body, context);
5434
4105
  return contents;
5435
4106
  }, "de_DeleteSubscriptionTargetCommand");
5436
- var de_DeleteSubscriptionTargetCommandError = /* @__PURE__ */ __name(async (output, context) => {
5437
- const parsedOutput = {
5438
- ...output,
5439
- body: await parseErrorBody(output.body, context)
5440
- };
5441
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5442
- switch (errorCode) {
5443
- case "AccessDeniedException":
5444
- case "com.amazonaws.datazone#AccessDeniedException":
5445
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5446
- case "ConflictException":
5447
- case "com.amazonaws.datazone#ConflictException":
5448
- throw await de_ConflictExceptionRes(parsedOutput, context);
5449
- case "InternalServerException":
5450
- case "com.amazonaws.datazone#InternalServerException":
5451
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5452
- case "ResourceNotFoundException":
5453
- case "com.amazonaws.datazone#ResourceNotFoundException":
5454
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5455
- case "ThrottlingException":
5456
- case "com.amazonaws.datazone#ThrottlingException":
5457
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5458
- case "UnauthorizedException":
5459
- case "com.amazonaws.datazone#UnauthorizedException":
5460
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5461
- case "ValidationException":
5462
- case "com.amazonaws.datazone#ValidationException":
5463
- throw await de_ValidationExceptionRes(parsedOutput, context);
5464
- default:
5465
- const parsedBody = parsedOutput.body;
5466
- return throwDefaultError({
5467
- output,
5468
- parsedBody,
5469
- errorCode
5470
- });
5471
- }
5472
- }, "de_DeleteSubscriptionTargetCommandError");
5473
4107
  var de_GetAssetCommand = /* @__PURE__ */ __name(async (output, context) => {
5474
4108
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5475
- return de_GetAssetCommandError(output, context);
4109
+ return de_CommandError(output, context);
5476
4110
  }
5477
4111
  const contents = (0, import_smithy_client.map)({
5478
4112
  $metadata: deserializeMetadata(output)
@@ -5500,43 +4134,9 @@ var de_GetAssetCommand = /* @__PURE__ */ __name(async (output, context) => {
5500
4134
  Object.assign(contents, doc);
5501
4135
  return contents;
5502
4136
  }, "de_GetAssetCommand");
5503
- var de_GetAssetCommandError = /* @__PURE__ */ __name(async (output, context) => {
5504
- const parsedOutput = {
5505
- ...output,
5506
- body: await parseErrorBody(output.body, context)
5507
- };
5508
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5509
- switch (errorCode) {
5510
- case "AccessDeniedException":
5511
- case "com.amazonaws.datazone#AccessDeniedException":
5512
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5513
- case "InternalServerException":
5514
- case "com.amazonaws.datazone#InternalServerException":
5515
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5516
- case "ResourceNotFoundException":
5517
- case "com.amazonaws.datazone#ResourceNotFoundException":
5518
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5519
- case "ThrottlingException":
5520
- case "com.amazonaws.datazone#ThrottlingException":
5521
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5522
- case "UnauthorizedException":
5523
- case "com.amazonaws.datazone#UnauthorizedException":
5524
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5525
- case "ValidationException":
5526
- case "com.amazonaws.datazone#ValidationException":
5527
- throw await de_ValidationExceptionRes(parsedOutput, context);
5528
- default:
5529
- const parsedBody = parsedOutput.body;
5530
- return throwDefaultError({
5531
- output,
5532
- parsedBody,
5533
- errorCode
5534
- });
5535
- }
5536
- }, "de_GetAssetCommandError");
5537
4137
  var de_GetAssetTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
5538
4138
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5539
- return de_GetAssetTypeCommandError(output, context);
4139
+ return de_CommandError(output, context);
5540
4140
  }
5541
4141
  const contents = (0, import_smithy_client.map)({
5542
4142
  $metadata: deserializeMetadata(output)
@@ -5559,43 +4159,9 @@ var de_GetAssetTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
5559
4159
  Object.assign(contents, doc);
5560
4160
  return contents;
5561
4161
  }, "de_GetAssetTypeCommand");
5562
- var de_GetAssetTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
5563
- const parsedOutput = {
5564
- ...output,
5565
- body: await parseErrorBody(output.body, context)
5566
- };
5567
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5568
- switch (errorCode) {
5569
- case "AccessDeniedException":
5570
- case "com.amazonaws.datazone#AccessDeniedException":
5571
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5572
- case "InternalServerException":
5573
- case "com.amazonaws.datazone#InternalServerException":
5574
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5575
- case "ResourceNotFoundException":
5576
- case "com.amazonaws.datazone#ResourceNotFoundException":
5577
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5578
- case "ThrottlingException":
5579
- case "com.amazonaws.datazone#ThrottlingException":
5580
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5581
- case "UnauthorizedException":
5582
- case "com.amazonaws.datazone#UnauthorizedException":
5583
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5584
- case "ValidationException":
5585
- case "com.amazonaws.datazone#ValidationException":
5586
- throw await de_ValidationExceptionRes(parsedOutput, context);
5587
- default:
5588
- const parsedBody = parsedOutput.body;
5589
- return throwDefaultError({
5590
- output,
5591
- parsedBody,
5592
- errorCode
5593
- });
5594
- }
5595
- }, "de_GetAssetTypeCommandError");
5596
4162
  var de_GetDataSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
5597
4163
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5598
- return de_GetDataSourceCommandError(output, context);
4164
+ return de_CommandError(output, context);
5599
4165
  }
5600
4166
  const contents = (0, import_smithy_client.map)({
5601
4167
  $metadata: deserializeMetadata(output)
@@ -5625,117 +4191,37 @@ var de_GetDataSourceCommand = /* @__PURE__ */ __name(async (output, context) =>
5625
4191
  updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
5626
4192
  });
5627
4193
  Object.assign(contents, doc);
5628
- return contents;
5629
- }, "de_GetDataSourceCommand");
5630
- var de_GetDataSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
5631
- const parsedOutput = {
5632
- ...output,
5633
- body: await parseErrorBody(output.body, context)
5634
- };
5635
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5636
- switch (errorCode) {
5637
- case "AccessDeniedException":
5638
- case "com.amazonaws.datazone#AccessDeniedException":
5639
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5640
- case "ConflictException":
5641
- case "com.amazonaws.datazone#ConflictException":
5642
- throw await de_ConflictExceptionRes(parsedOutput, context);
5643
- case "InternalServerException":
5644
- case "com.amazonaws.datazone#InternalServerException":
5645
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5646
- case "ResourceNotFoundException":
5647
- case "com.amazonaws.datazone#ResourceNotFoundException":
5648
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5649
- case "ServiceQuotaExceededException":
5650
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
5651
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
5652
- case "ThrottlingException":
5653
- case "com.amazonaws.datazone#ThrottlingException":
5654
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5655
- case "UnauthorizedException":
5656
- case "com.amazonaws.datazone#UnauthorizedException":
5657
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5658
- case "ValidationException":
5659
- case "com.amazonaws.datazone#ValidationException":
5660
- throw await de_ValidationExceptionRes(parsedOutput, context);
5661
- default:
5662
- const parsedBody = parsedOutput.body;
5663
- return throwDefaultError({
5664
- output,
5665
- parsedBody,
5666
- errorCode
5667
- });
5668
- }
5669
- }, "de_GetDataSourceCommandError");
5670
- var de_GetDataSourceRunCommand = /* @__PURE__ */ __name(async (output, context) => {
5671
- if (output.statusCode !== 200 && output.statusCode >= 300) {
5672
- return de_GetDataSourceRunCommandError(output, context);
5673
- }
5674
- const contents = (0, import_smithy_client.map)({
5675
- $metadata: deserializeMetadata(output)
5676
- });
5677
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
5678
- const doc = (0, import_smithy_client.take)(data, {
5679
- createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
5680
- dataSourceConfigurationSnapshot: import_smithy_client.expectString,
5681
- dataSourceId: import_smithy_client.expectString,
5682
- domainId: import_smithy_client.expectString,
5683
- errorMessage: import_smithy_client._json,
5684
- id: import_smithy_client.expectString,
5685
- projectId: import_smithy_client.expectString,
5686
- runStatisticsForAssets: import_smithy_client._json,
5687
- startedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
5688
- status: import_smithy_client.expectString,
5689
- stoppedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
5690
- type: import_smithy_client.expectString,
5691
- updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
5692
- });
5693
- Object.assign(contents, doc);
5694
- return contents;
5695
- }, "de_GetDataSourceRunCommand");
5696
- var de_GetDataSourceRunCommandError = /* @__PURE__ */ __name(async (output, context) => {
5697
- const parsedOutput = {
5698
- ...output,
5699
- body: await parseErrorBody(output.body, context)
5700
- };
5701
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5702
- switch (errorCode) {
5703
- case "AccessDeniedException":
5704
- case "com.amazonaws.datazone#AccessDeniedException":
5705
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5706
- case "ConflictException":
5707
- case "com.amazonaws.datazone#ConflictException":
5708
- throw await de_ConflictExceptionRes(parsedOutput, context);
5709
- case "InternalServerException":
5710
- case "com.amazonaws.datazone#InternalServerException":
5711
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5712
- case "ResourceNotFoundException":
5713
- case "com.amazonaws.datazone#ResourceNotFoundException":
5714
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5715
- case "ServiceQuotaExceededException":
5716
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
5717
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
5718
- case "ThrottlingException":
5719
- case "com.amazonaws.datazone#ThrottlingException":
5720
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5721
- case "UnauthorizedException":
5722
- case "com.amazonaws.datazone#UnauthorizedException":
5723
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5724
- case "ValidationException":
5725
- case "com.amazonaws.datazone#ValidationException":
5726
- throw await de_ValidationExceptionRes(parsedOutput, context);
5727
- default:
5728
- const parsedBody = parsedOutput.body;
5729
- return throwDefaultError({
5730
- output,
5731
- parsedBody,
5732
- errorCode
5733
- });
4194
+ return contents;
4195
+ }, "de_GetDataSourceCommand");
4196
+ var de_GetDataSourceRunCommand = /* @__PURE__ */ __name(async (output, context) => {
4197
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
4198
+ return de_CommandError(output, context);
5734
4199
  }
5735
- }, "de_GetDataSourceRunCommandError");
4200
+ const contents = (0, import_smithy_client.map)({
4201
+ $metadata: deserializeMetadata(output)
4202
+ });
4203
+ const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
4204
+ const doc = (0, import_smithy_client.take)(data, {
4205
+ createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
4206
+ dataSourceConfigurationSnapshot: import_smithy_client.expectString,
4207
+ dataSourceId: import_smithy_client.expectString,
4208
+ domainId: import_smithy_client.expectString,
4209
+ errorMessage: import_smithy_client._json,
4210
+ id: import_smithy_client.expectString,
4211
+ projectId: import_smithy_client.expectString,
4212
+ runStatisticsForAssets: import_smithy_client._json,
4213
+ startedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
4214
+ status: import_smithy_client.expectString,
4215
+ stoppedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
4216
+ type: import_smithy_client.expectString,
4217
+ updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
4218
+ });
4219
+ Object.assign(contents, doc);
4220
+ return contents;
4221
+ }, "de_GetDataSourceRunCommand");
5736
4222
  var de_GetDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
5737
4223
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5738
- return de_GetDomainCommandError(output, context);
4224
+ return de_CommandError(output, context);
5739
4225
  }
5740
4226
  const contents = (0, import_smithy_client.map)({
5741
4227
  $metadata: deserializeMetadata(output)
@@ -5758,46 +4244,9 @@ var de_GetDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
5758
4244
  Object.assign(contents, doc);
5759
4245
  return contents;
5760
4246
  }, "de_GetDomainCommand");
5761
- var de_GetDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
5762
- const parsedOutput = {
5763
- ...output,
5764
- body: await parseErrorBody(output.body, context)
5765
- };
5766
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5767
- switch (errorCode) {
5768
- case "AccessDeniedException":
5769
- case "com.amazonaws.datazone#AccessDeniedException":
5770
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5771
- case "InternalServerException":
5772
- case "com.amazonaws.datazone#InternalServerException":
5773
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5774
- case "ResourceNotFoundException":
5775
- case "com.amazonaws.datazone#ResourceNotFoundException":
5776
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5777
- case "ServiceQuotaExceededException":
5778
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
5779
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
5780
- case "ThrottlingException":
5781
- case "com.amazonaws.datazone#ThrottlingException":
5782
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5783
- case "UnauthorizedException":
5784
- case "com.amazonaws.datazone#UnauthorizedException":
5785
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5786
- case "ValidationException":
5787
- case "com.amazonaws.datazone#ValidationException":
5788
- throw await de_ValidationExceptionRes(parsedOutput, context);
5789
- default:
5790
- const parsedBody = parsedOutput.body;
5791
- return throwDefaultError({
5792
- output,
5793
- parsedBody,
5794
- errorCode
5795
- });
5796
- }
5797
- }, "de_GetDomainCommandError");
5798
4247
  var de_GetEnvironmentCommand = /* @__PURE__ */ __name(async (output, context) => {
5799
4248
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5800
- return de_GetEnvironmentCommandError(output, context);
4249
+ return de_CommandError(output, context);
5801
4250
  }
5802
4251
  const contents = (0, import_smithy_client.map)({
5803
4252
  $metadata: deserializeMetadata(output)
@@ -5829,43 +4278,9 @@ var de_GetEnvironmentCommand = /* @__PURE__ */ __name(async (output, context) =>
5829
4278
  Object.assign(contents, doc);
5830
4279
  return contents;
5831
4280
  }, "de_GetEnvironmentCommand");
5832
- var de_GetEnvironmentCommandError = /* @__PURE__ */ __name(async (output, context) => {
5833
- const parsedOutput = {
5834
- ...output,
5835
- body: await parseErrorBody(output.body, context)
5836
- };
5837
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5838
- switch (errorCode) {
5839
- case "AccessDeniedException":
5840
- case "com.amazonaws.datazone#AccessDeniedException":
5841
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5842
- case "InternalServerException":
5843
- case "com.amazonaws.datazone#InternalServerException":
5844
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5845
- case "ResourceNotFoundException":
5846
- case "com.amazonaws.datazone#ResourceNotFoundException":
5847
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5848
- case "ThrottlingException":
5849
- case "com.amazonaws.datazone#ThrottlingException":
5850
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5851
- case "UnauthorizedException":
5852
- case "com.amazonaws.datazone#UnauthorizedException":
5853
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5854
- case "ValidationException":
5855
- case "com.amazonaws.datazone#ValidationException":
5856
- throw await de_ValidationExceptionRes(parsedOutput, context);
5857
- default:
5858
- const parsedBody = parsedOutput.body;
5859
- return throwDefaultError({
5860
- output,
5861
- parsedBody,
5862
- errorCode
5863
- });
5864
- }
5865
- }, "de_GetEnvironmentCommandError");
5866
4281
  var de_GetEnvironmentBlueprintCommand = /* @__PURE__ */ __name(async (output, context) => {
5867
4282
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5868
- return de_GetEnvironmentBlueprintCommandError(output, context);
4283
+ return de_CommandError(output, context);
5869
4284
  }
5870
4285
  const contents = (0, import_smithy_client.map)({
5871
4286
  $metadata: deserializeMetadata(output)
@@ -5886,43 +4301,9 @@ var de_GetEnvironmentBlueprintCommand = /* @__PURE__ */ __name(async (output, co
5886
4301
  Object.assign(contents, doc);
5887
4302
  return contents;
5888
4303
  }, "de_GetEnvironmentBlueprintCommand");
5889
- var de_GetEnvironmentBlueprintCommandError = /* @__PURE__ */ __name(async (output, context) => {
5890
- const parsedOutput = {
5891
- ...output,
5892
- body: await parseErrorBody(output.body, context)
5893
- };
5894
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5895
- switch (errorCode) {
5896
- case "AccessDeniedException":
5897
- case "com.amazonaws.datazone#AccessDeniedException":
5898
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5899
- case "InternalServerException":
5900
- case "com.amazonaws.datazone#InternalServerException":
5901
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5902
- case "ResourceNotFoundException":
5903
- case "com.amazonaws.datazone#ResourceNotFoundException":
5904
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5905
- case "ThrottlingException":
5906
- case "com.amazonaws.datazone#ThrottlingException":
5907
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5908
- case "UnauthorizedException":
5909
- case "com.amazonaws.datazone#UnauthorizedException":
5910
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5911
- case "ValidationException":
5912
- case "com.amazonaws.datazone#ValidationException":
5913
- throw await de_ValidationExceptionRes(parsedOutput, context);
5914
- default:
5915
- const parsedBody = parsedOutput.body;
5916
- return throwDefaultError({
5917
- output,
5918
- parsedBody,
5919
- errorCode
5920
- });
5921
- }
5922
- }, "de_GetEnvironmentBlueprintCommandError");
5923
4304
  var de_GetEnvironmentBlueprintConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
5924
4305
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5925
- return de_GetEnvironmentBlueprintConfigurationCommandError(output, context);
4306
+ return de_CommandError(output, context);
5926
4307
  }
5927
4308
  const contents = (0, import_smithy_client.map)({
5928
4309
  $metadata: deserializeMetadata(output)
@@ -5941,43 +4322,9 @@ var de_GetEnvironmentBlueprintConfigurationCommand = /* @__PURE__ */ __name(asyn
5941
4322
  Object.assign(contents, doc);
5942
4323
  return contents;
5943
4324
  }, "de_GetEnvironmentBlueprintConfigurationCommand");
5944
- var de_GetEnvironmentBlueprintConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
5945
- const parsedOutput = {
5946
- ...output,
5947
- body: await parseErrorBody(output.body, context)
5948
- };
5949
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5950
- switch (errorCode) {
5951
- case "AccessDeniedException":
5952
- case "com.amazonaws.datazone#AccessDeniedException":
5953
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5954
- case "InternalServerException":
5955
- case "com.amazonaws.datazone#InternalServerException":
5956
- throw await de_InternalServerExceptionRes(parsedOutput, context);
5957
- case "ResourceNotFoundException":
5958
- case "com.amazonaws.datazone#ResourceNotFoundException":
5959
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5960
- case "ThrottlingException":
5961
- case "com.amazonaws.datazone#ThrottlingException":
5962
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
5963
- case "UnauthorizedException":
5964
- case "com.amazonaws.datazone#UnauthorizedException":
5965
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
5966
- case "ValidationException":
5967
- case "com.amazonaws.datazone#ValidationException":
5968
- throw await de_ValidationExceptionRes(parsedOutput, context);
5969
- default:
5970
- const parsedBody = parsedOutput.body;
5971
- return throwDefaultError({
5972
- output,
5973
- parsedBody,
5974
- errorCode
5975
- });
5976
- }
5977
- }, "de_GetEnvironmentBlueprintConfigurationCommandError");
5978
4325
  var de_GetEnvironmentProfileCommand = /* @__PURE__ */ __name(async (output, context) => {
5979
4326
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5980
- return de_GetEnvironmentProfileCommandError(output, context);
4327
+ return de_CommandError(output, context);
5981
4328
  }
5982
4329
  const contents = (0, import_smithy_client.map)({
5983
4330
  $metadata: deserializeMetadata(output)
@@ -6000,43 +4347,9 @@ var de_GetEnvironmentProfileCommand = /* @__PURE__ */ __name(async (output, cont
6000
4347
  Object.assign(contents, doc);
6001
4348
  return contents;
6002
4349
  }, "de_GetEnvironmentProfileCommand");
6003
- var de_GetEnvironmentProfileCommandError = /* @__PURE__ */ __name(async (output, context) => {
6004
- const parsedOutput = {
6005
- ...output,
6006
- body: await parseErrorBody(output.body, context)
6007
- };
6008
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6009
- switch (errorCode) {
6010
- case "AccessDeniedException":
6011
- case "com.amazonaws.datazone#AccessDeniedException":
6012
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6013
- case "InternalServerException":
6014
- case "com.amazonaws.datazone#InternalServerException":
6015
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6016
- case "ResourceNotFoundException":
6017
- case "com.amazonaws.datazone#ResourceNotFoundException":
6018
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6019
- case "ThrottlingException":
6020
- case "com.amazonaws.datazone#ThrottlingException":
6021
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6022
- case "UnauthorizedException":
6023
- case "com.amazonaws.datazone#UnauthorizedException":
6024
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6025
- case "ValidationException":
6026
- case "com.amazonaws.datazone#ValidationException":
6027
- throw await de_ValidationExceptionRes(parsedOutput, context);
6028
- default:
6029
- const parsedBody = parsedOutput.body;
6030
- return throwDefaultError({
6031
- output,
6032
- parsedBody,
6033
- errorCode
6034
- });
6035
- }
6036
- }, "de_GetEnvironmentProfileCommandError");
6037
4350
  var de_GetFormTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
6038
4351
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6039
- return de_GetFormTypeCommandError(output, context);
4352
+ return de_CommandError(output, context);
6040
4353
  }
6041
4354
  const contents = (0, import_smithy_client.map)({
6042
4355
  $metadata: deserializeMetadata(output)
@@ -6059,43 +4372,9 @@ var de_GetFormTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
6059
4372
  Object.assign(contents, doc);
6060
4373
  return contents;
6061
4374
  }, "de_GetFormTypeCommand");
6062
- var de_GetFormTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
6063
- const parsedOutput = {
6064
- ...output,
6065
- body: await parseErrorBody(output.body, context)
6066
- };
6067
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6068
- switch (errorCode) {
6069
- case "AccessDeniedException":
6070
- case "com.amazonaws.datazone#AccessDeniedException":
6071
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6072
- case "InternalServerException":
6073
- case "com.amazonaws.datazone#InternalServerException":
6074
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6075
- case "ResourceNotFoundException":
6076
- case "com.amazonaws.datazone#ResourceNotFoundException":
6077
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6078
- case "ThrottlingException":
6079
- case "com.amazonaws.datazone#ThrottlingException":
6080
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6081
- case "UnauthorizedException":
6082
- case "com.amazonaws.datazone#UnauthorizedException":
6083
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6084
- case "ValidationException":
6085
- case "com.amazonaws.datazone#ValidationException":
6086
- throw await de_ValidationExceptionRes(parsedOutput, context);
6087
- default:
6088
- const parsedBody = parsedOutput.body;
6089
- return throwDefaultError({
6090
- output,
6091
- parsedBody,
6092
- errorCode
6093
- });
6094
- }
6095
- }, "de_GetFormTypeCommandError");
6096
4375
  var de_GetGlossaryCommand = /* @__PURE__ */ __name(async (output, context) => {
6097
4376
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6098
- return de_GetGlossaryCommandError(output, context);
4377
+ return de_CommandError(output, context);
6099
4378
  }
6100
4379
  const contents = (0, import_smithy_client.map)({
6101
4380
  $metadata: deserializeMetadata(output)
@@ -6113,46 +4392,12 @@ var de_GetGlossaryCommand = /* @__PURE__ */ __name(async (output, context) => {
6113
4392
  updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
6114
4393
  updatedBy: import_smithy_client.expectString
6115
4394
  });
6116
- Object.assign(contents, doc);
6117
- return contents;
6118
- }, "de_GetGlossaryCommand");
6119
- var de_GetGlossaryCommandError = /* @__PURE__ */ __name(async (output, context) => {
6120
- const parsedOutput = {
6121
- ...output,
6122
- body: await parseErrorBody(output.body, context)
6123
- };
6124
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6125
- switch (errorCode) {
6126
- case "AccessDeniedException":
6127
- case "com.amazonaws.datazone#AccessDeniedException":
6128
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6129
- case "InternalServerException":
6130
- case "com.amazonaws.datazone#InternalServerException":
6131
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6132
- case "ResourceNotFoundException":
6133
- case "com.amazonaws.datazone#ResourceNotFoundException":
6134
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6135
- case "ThrottlingException":
6136
- case "com.amazonaws.datazone#ThrottlingException":
6137
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6138
- case "UnauthorizedException":
6139
- case "com.amazonaws.datazone#UnauthorizedException":
6140
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6141
- case "ValidationException":
6142
- case "com.amazonaws.datazone#ValidationException":
6143
- throw await de_ValidationExceptionRes(parsedOutput, context);
6144
- default:
6145
- const parsedBody = parsedOutput.body;
6146
- return throwDefaultError({
6147
- output,
6148
- parsedBody,
6149
- errorCode
6150
- });
6151
- }
6152
- }, "de_GetGlossaryCommandError");
4395
+ Object.assign(contents, doc);
4396
+ return contents;
4397
+ }, "de_GetGlossaryCommand");
6153
4398
  var de_GetGlossaryTermCommand = /* @__PURE__ */ __name(async (output, context) => {
6154
4399
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6155
- return de_GetGlossaryTermCommandError(output, context);
4400
+ return de_CommandError(output, context);
6156
4401
  }
6157
4402
  const contents = (0, import_smithy_client.map)({
6158
4403
  $metadata: deserializeMetadata(output)
@@ -6175,43 +4420,9 @@ var de_GetGlossaryTermCommand = /* @__PURE__ */ __name(async (output, context) =
6175
4420
  Object.assign(contents, doc);
6176
4421
  return contents;
6177
4422
  }, "de_GetGlossaryTermCommand");
6178
- var de_GetGlossaryTermCommandError = /* @__PURE__ */ __name(async (output, context) => {
6179
- const parsedOutput = {
6180
- ...output,
6181
- body: await parseErrorBody(output.body, context)
6182
- };
6183
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6184
- switch (errorCode) {
6185
- case "AccessDeniedException":
6186
- case "com.amazonaws.datazone#AccessDeniedException":
6187
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6188
- case "InternalServerException":
6189
- case "com.amazonaws.datazone#InternalServerException":
6190
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6191
- case "ResourceNotFoundException":
6192
- case "com.amazonaws.datazone#ResourceNotFoundException":
6193
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6194
- case "ThrottlingException":
6195
- case "com.amazonaws.datazone#ThrottlingException":
6196
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6197
- case "UnauthorizedException":
6198
- case "com.amazonaws.datazone#UnauthorizedException":
6199
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6200
- case "ValidationException":
6201
- case "com.amazonaws.datazone#ValidationException":
6202
- throw await de_ValidationExceptionRes(parsedOutput, context);
6203
- default:
6204
- const parsedBody = parsedOutput.body;
6205
- return throwDefaultError({
6206
- output,
6207
- parsedBody,
6208
- errorCode
6209
- });
6210
- }
6211
- }, "de_GetGlossaryTermCommandError");
6212
4423
  var de_GetGroupProfileCommand = /* @__PURE__ */ __name(async (output, context) => {
6213
4424
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6214
- return de_GetGroupProfileCommandError(output, context);
4425
+ return de_CommandError(output, context);
6215
4426
  }
6216
4427
  const contents = (0, import_smithy_client.map)({
6217
4428
  $metadata: deserializeMetadata(output)
@@ -6226,43 +4437,9 @@ var de_GetGroupProfileCommand = /* @__PURE__ */ __name(async (output, context) =
6226
4437
  Object.assign(contents, doc);
6227
4438
  return contents;
6228
4439
  }, "de_GetGroupProfileCommand");
6229
- var de_GetGroupProfileCommandError = /* @__PURE__ */ __name(async (output, context) => {
6230
- const parsedOutput = {
6231
- ...output,
6232
- body: await parseErrorBody(output.body, context)
6233
- };
6234
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6235
- switch (errorCode) {
6236
- case "AccessDeniedException":
6237
- case "com.amazonaws.datazone#AccessDeniedException":
6238
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6239
- case "InternalServerException":
6240
- case "com.amazonaws.datazone#InternalServerException":
6241
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6242
- case "ResourceNotFoundException":
6243
- case "com.amazonaws.datazone#ResourceNotFoundException":
6244
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6245
- case "ThrottlingException":
6246
- case "com.amazonaws.datazone#ThrottlingException":
6247
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6248
- case "UnauthorizedException":
6249
- case "com.amazonaws.datazone#UnauthorizedException":
6250
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6251
- case "ValidationException":
6252
- case "com.amazonaws.datazone#ValidationException":
6253
- throw await de_ValidationExceptionRes(parsedOutput, context);
6254
- default:
6255
- const parsedBody = parsedOutput.body;
6256
- return throwDefaultError({
6257
- output,
6258
- parsedBody,
6259
- errorCode
6260
- });
6261
- }
6262
- }, "de_GetGroupProfileCommandError");
6263
4440
  var de_GetIamPortalLoginUrlCommand = /* @__PURE__ */ __name(async (output, context) => {
6264
4441
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6265
- return de_GetIamPortalLoginUrlCommandError(output, context);
4442
+ return de_CommandError(output, context);
6266
4443
  }
6267
4444
  const contents = (0, import_smithy_client.map)({
6268
4445
  $metadata: deserializeMetadata(output)
@@ -6275,46 +4452,9 @@ var de_GetIamPortalLoginUrlCommand = /* @__PURE__ */ __name(async (output, conte
6275
4452
  Object.assign(contents, doc);
6276
4453
  return contents;
6277
4454
  }, "de_GetIamPortalLoginUrlCommand");
6278
- var de_GetIamPortalLoginUrlCommandError = /* @__PURE__ */ __name(async (output, context) => {
6279
- const parsedOutput = {
6280
- ...output,
6281
- body: await parseErrorBody(output.body, context)
6282
- };
6283
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6284
- switch (errorCode) {
6285
- case "AccessDeniedException":
6286
- case "com.amazonaws.datazone#AccessDeniedException":
6287
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6288
- case "ConflictException":
6289
- case "com.amazonaws.datazone#ConflictException":
6290
- throw await de_ConflictExceptionRes(parsedOutput, context);
6291
- case "InternalServerException":
6292
- case "com.amazonaws.datazone#InternalServerException":
6293
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6294
- case "ResourceNotFoundException":
6295
- case "com.amazonaws.datazone#ResourceNotFoundException":
6296
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6297
- case "ThrottlingException":
6298
- case "com.amazonaws.datazone#ThrottlingException":
6299
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6300
- case "UnauthorizedException":
6301
- case "com.amazonaws.datazone#UnauthorizedException":
6302
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6303
- case "ValidationException":
6304
- case "com.amazonaws.datazone#ValidationException":
6305
- throw await de_ValidationExceptionRes(parsedOutput, context);
6306
- default:
6307
- const parsedBody = parsedOutput.body;
6308
- return throwDefaultError({
6309
- output,
6310
- parsedBody,
6311
- errorCode
6312
- });
6313
- }
6314
- }, "de_GetIamPortalLoginUrlCommandError");
6315
4455
  var de_GetListingCommand = /* @__PURE__ */ __name(async (output, context) => {
6316
4456
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6317
- return de_GetListingCommandError(output, context);
4457
+ return de_CommandError(output, context);
6318
4458
  }
6319
4459
  const contents = (0, import_smithy_client.map)({
6320
4460
  $metadata: deserializeMetadata(output)
@@ -6336,43 +4476,9 @@ var de_GetListingCommand = /* @__PURE__ */ __name(async (output, context) => {
6336
4476
  Object.assign(contents, doc);
6337
4477
  return contents;
6338
4478
  }, "de_GetListingCommand");
6339
- var de_GetListingCommandError = /* @__PURE__ */ __name(async (output, context) => {
6340
- const parsedOutput = {
6341
- ...output,
6342
- body: await parseErrorBody(output.body, context)
6343
- };
6344
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6345
- switch (errorCode) {
6346
- case "AccessDeniedException":
6347
- case "com.amazonaws.datazone#AccessDeniedException":
6348
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6349
- case "InternalServerException":
6350
- case "com.amazonaws.datazone#InternalServerException":
6351
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6352
- case "ResourceNotFoundException":
6353
- case "com.amazonaws.datazone#ResourceNotFoundException":
6354
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6355
- case "ThrottlingException":
6356
- case "com.amazonaws.datazone#ThrottlingException":
6357
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6358
- case "UnauthorizedException":
6359
- case "com.amazonaws.datazone#UnauthorizedException":
6360
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6361
- case "ValidationException":
6362
- case "com.amazonaws.datazone#ValidationException":
6363
- throw await de_ValidationExceptionRes(parsedOutput, context);
6364
- default:
6365
- const parsedBody = parsedOutput.body;
6366
- return throwDefaultError({
6367
- output,
6368
- parsedBody,
6369
- errorCode
6370
- });
6371
- }
6372
- }, "de_GetListingCommandError");
6373
4479
  var de_GetProjectCommand = /* @__PURE__ */ __name(async (output, context) => {
6374
4480
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6375
- return de_GetProjectCommandError(output, context);
4481
+ return de_CommandError(output, context);
6376
4482
  }
6377
4483
  const contents = (0, import_smithy_client.map)({
6378
4484
  $metadata: deserializeMetadata(output)
@@ -6393,43 +4499,9 @@ var de_GetProjectCommand = /* @__PURE__ */ __name(async (output, context) => {
6393
4499
  Object.assign(contents, doc);
6394
4500
  return contents;
6395
4501
  }, "de_GetProjectCommand");
6396
- var de_GetProjectCommandError = /* @__PURE__ */ __name(async (output, context) => {
6397
- const parsedOutput = {
6398
- ...output,
6399
- body: await parseErrorBody(output.body, context)
6400
- };
6401
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6402
- switch (errorCode) {
6403
- case "AccessDeniedException":
6404
- case "com.amazonaws.datazone#AccessDeniedException":
6405
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6406
- case "InternalServerException":
6407
- case "com.amazonaws.datazone#InternalServerException":
6408
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6409
- case "ResourceNotFoundException":
6410
- case "com.amazonaws.datazone#ResourceNotFoundException":
6411
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6412
- case "ThrottlingException":
6413
- case "com.amazonaws.datazone#ThrottlingException":
6414
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6415
- case "UnauthorizedException":
6416
- case "com.amazonaws.datazone#UnauthorizedException":
6417
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6418
- case "ValidationException":
6419
- case "com.amazonaws.datazone#ValidationException":
6420
- throw await de_ValidationExceptionRes(parsedOutput, context);
6421
- default:
6422
- const parsedBody = parsedOutput.body;
6423
- return throwDefaultError({
6424
- output,
6425
- parsedBody,
6426
- errorCode
6427
- });
6428
- }
6429
- }, "de_GetProjectCommandError");
6430
4502
  var de_GetSubscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
6431
4503
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6432
- return de_GetSubscriptionCommandError(output, context);
4504
+ return de_CommandError(output, context);
6433
4505
  }
6434
4506
  const contents = (0, import_smithy_client.map)({
6435
4507
  $metadata: deserializeMetadata(output)
@@ -6447,105 +4519,37 @@ var de_GetSubscriptionCommand = /* @__PURE__ */ __name(async (output, context) =
6447
4519
  subscriptionRequestId: import_smithy_client.expectString,
6448
4520
  updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
6449
4521
  updatedBy: import_smithy_client.expectString
6450
- });
6451
- Object.assign(contents, doc);
6452
- return contents;
6453
- }, "de_GetSubscriptionCommand");
6454
- var de_GetSubscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
6455
- const parsedOutput = {
6456
- ...output,
6457
- body: await parseErrorBody(output.body, context)
6458
- };
6459
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6460
- switch (errorCode) {
6461
- case "AccessDeniedException":
6462
- case "com.amazonaws.datazone#AccessDeniedException":
6463
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6464
- case "InternalServerException":
6465
- case "com.amazonaws.datazone#InternalServerException":
6466
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6467
- case "ResourceNotFoundException":
6468
- case "com.amazonaws.datazone#ResourceNotFoundException":
6469
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6470
- case "ThrottlingException":
6471
- case "com.amazonaws.datazone#ThrottlingException":
6472
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6473
- case "UnauthorizedException":
6474
- case "com.amazonaws.datazone#UnauthorizedException":
6475
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6476
- case "ValidationException":
6477
- case "com.amazonaws.datazone#ValidationException":
6478
- throw await de_ValidationExceptionRes(parsedOutput, context);
6479
- default:
6480
- const parsedBody = parsedOutput.body;
6481
- return throwDefaultError({
6482
- output,
6483
- parsedBody,
6484
- errorCode
6485
- });
6486
- }
6487
- }, "de_GetSubscriptionCommandError");
6488
- var de_GetSubscriptionGrantCommand = /* @__PURE__ */ __name(async (output, context) => {
6489
- if (output.statusCode !== 200 && output.statusCode >= 300) {
6490
- return de_GetSubscriptionGrantCommandError(output, context);
6491
- }
6492
- const contents = (0, import_smithy_client.map)({
6493
- $metadata: deserializeMetadata(output)
6494
- });
6495
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
6496
- const doc = (0, import_smithy_client.take)(data, {
6497
- assets: (_) => de_SubscribedAssets(_, context),
6498
- createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
6499
- createdBy: import_smithy_client.expectString,
6500
- domainId: import_smithy_client.expectString,
6501
- grantedEntity: (_) => (0, import_smithy_client._json)((0, import_core.awsExpectUnion)(_)),
6502
- id: import_smithy_client.expectString,
6503
- status: import_smithy_client.expectString,
6504
- subscriptionId: import_smithy_client.expectString,
6505
- subscriptionTargetId: import_smithy_client.expectString,
6506
- updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
6507
- updatedBy: import_smithy_client.expectString
6508
- });
6509
- Object.assign(contents, doc);
6510
- return contents;
6511
- }, "de_GetSubscriptionGrantCommand");
6512
- var de_GetSubscriptionGrantCommandError = /* @__PURE__ */ __name(async (output, context) => {
6513
- const parsedOutput = {
6514
- ...output,
6515
- body: await parseErrorBody(output.body, context)
6516
- };
6517
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6518
- switch (errorCode) {
6519
- case "AccessDeniedException":
6520
- case "com.amazonaws.datazone#AccessDeniedException":
6521
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6522
- case "InternalServerException":
6523
- case "com.amazonaws.datazone#InternalServerException":
6524
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6525
- case "ResourceNotFoundException":
6526
- case "com.amazonaws.datazone#ResourceNotFoundException":
6527
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6528
- case "ThrottlingException":
6529
- case "com.amazonaws.datazone#ThrottlingException":
6530
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6531
- case "UnauthorizedException":
6532
- case "com.amazonaws.datazone#UnauthorizedException":
6533
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6534
- case "ValidationException":
6535
- case "com.amazonaws.datazone#ValidationException":
6536
- throw await de_ValidationExceptionRes(parsedOutput, context);
6537
- default:
6538
- const parsedBody = parsedOutput.body;
6539
- return throwDefaultError({
6540
- output,
6541
- parsedBody,
6542
- errorCode
6543
- });
4522
+ });
4523
+ Object.assign(contents, doc);
4524
+ return contents;
4525
+ }, "de_GetSubscriptionCommand");
4526
+ var de_GetSubscriptionGrantCommand = /* @__PURE__ */ __name(async (output, context) => {
4527
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
4528
+ return de_CommandError(output, context);
6544
4529
  }
6545
- }, "de_GetSubscriptionGrantCommandError");
4530
+ const contents = (0, import_smithy_client.map)({
4531
+ $metadata: deserializeMetadata(output)
4532
+ });
4533
+ const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
4534
+ const doc = (0, import_smithy_client.take)(data, {
4535
+ assets: (_) => de_SubscribedAssets(_, context),
4536
+ createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
4537
+ createdBy: import_smithy_client.expectString,
4538
+ domainId: import_smithy_client.expectString,
4539
+ grantedEntity: (_) => (0, import_smithy_client._json)((0, import_core.awsExpectUnion)(_)),
4540
+ id: import_smithy_client.expectString,
4541
+ status: import_smithy_client.expectString,
4542
+ subscriptionId: import_smithy_client.expectString,
4543
+ subscriptionTargetId: import_smithy_client.expectString,
4544
+ updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
4545
+ updatedBy: import_smithy_client.expectString
4546
+ });
4547
+ Object.assign(contents, doc);
4548
+ return contents;
4549
+ }, "de_GetSubscriptionGrantCommand");
6546
4550
  var de_GetSubscriptionRequestDetailsCommand = /* @__PURE__ */ __name(async (output, context) => {
6547
4551
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6548
- return de_GetSubscriptionRequestDetailsCommandError(output, context);
4552
+ return de_CommandError(output, context);
6549
4553
  }
6550
4554
  const contents = (0, import_smithy_client.map)({
6551
4555
  $metadata: deserializeMetadata(output)
@@ -6568,43 +4572,9 @@ var de_GetSubscriptionRequestDetailsCommand = /* @__PURE__ */ __name(async (outp
6568
4572
  Object.assign(contents, doc);
6569
4573
  return contents;
6570
4574
  }, "de_GetSubscriptionRequestDetailsCommand");
6571
- var de_GetSubscriptionRequestDetailsCommandError = /* @__PURE__ */ __name(async (output, context) => {
6572
- const parsedOutput = {
6573
- ...output,
6574
- body: await parseErrorBody(output.body, context)
6575
- };
6576
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6577
- switch (errorCode) {
6578
- case "AccessDeniedException":
6579
- case "com.amazonaws.datazone#AccessDeniedException":
6580
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6581
- case "InternalServerException":
6582
- case "com.amazonaws.datazone#InternalServerException":
6583
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6584
- case "ResourceNotFoundException":
6585
- case "com.amazonaws.datazone#ResourceNotFoundException":
6586
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6587
- case "ThrottlingException":
6588
- case "com.amazonaws.datazone#ThrottlingException":
6589
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6590
- case "UnauthorizedException":
6591
- case "com.amazonaws.datazone#UnauthorizedException":
6592
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6593
- case "ValidationException":
6594
- case "com.amazonaws.datazone#ValidationException":
6595
- throw await de_ValidationExceptionRes(parsedOutput, context);
6596
- default:
6597
- const parsedBody = parsedOutput.body;
6598
- return throwDefaultError({
6599
- output,
6600
- parsedBody,
6601
- errorCode
6602
- });
6603
- }
6604
- }, "de_GetSubscriptionRequestDetailsCommandError");
6605
4575
  var de_GetSubscriptionTargetCommand = /* @__PURE__ */ __name(async (output, context) => {
6606
4576
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6607
- return de_GetSubscriptionTargetCommandError(output, context);
4577
+ return de_CommandError(output, context);
6608
4578
  }
6609
4579
  const contents = (0, import_smithy_client.map)({
6610
4580
  $metadata: deserializeMetadata(output)
@@ -6630,43 +4600,9 @@ var de_GetSubscriptionTargetCommand = /* @__PURE__ */ __name(async (output, cont
6630
4600
  Object.assign(contents, doc);
6631
4601
  return contents;
6632
4602
  }, "de_GetSubscriptionTargetCommand");
6633
- var de_GetSubscriptionTargetCommandError = /* @__PURE__ */ __name(async (output, context) => {
6634
- const parsedOutput = {
6635
- ...output,
6636
- body: await parseErrorBody(output.body, context)
6637
- };
6638
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6639
- switch (errorCode) {
6640
- case "AccessDeniedException":
6641
- case "com.amazonaws.datazone#AccessDeniedException":
6642
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6643
- case "InternalServerException":
6644
- case "com.amazonaws.datazone#InternalServerException":
6645
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6646
- case "ResourceNotFoundException":
6647
- case "com.amazonaws.datazone#ResourceNotFoundException":
6648
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6649
- case "ThrottlingException":
6650
- case "com.amazonaws.datazone#ThrottlingException":
6651
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6652
- case "UnauthorizedException":
6653
- case "com.amazonaws.datazone#UnauthorizedException":
6654
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6655
- case "ValidationException":
6656
- case "com.amazonaws.datazone#ValidationException":
6657
- throw await de_ValidationExceptionRes(parsedOutput, context);
6658
- default:
6659
- const parsedBody = parsedOutput.body;
6660
- return throwDefaultError({
6661
- output,
6662
- parsedBody,
6663
- errorCode
6664
- });
6665
- }
6666
- }, "de_GetSubscriptionTargetCommandError");
6667
4603
  var de_GetUserProfileCommand = /* @__PURE__ */ __name(async (output, context) => {
6668
4604
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6669
- return de_GetUserProfileCommandError(output, context);
4605
+ return de_CommandError(output, context);
6670
4606
  }
6671
4607
  const contents = (0, import_smithy_client.map)({
6672
4608
  $metadata: deserializeMetadata(output)
@@ -6682,43 +4618,9 @@ var de_GetUserProfileCommand = /* @__PURE__ */ __name(async (output, context) =>
6682
4618
  Object.assign(contents, doc);
6683
4619
  return contents;
6684
4620
  }, "de_GetUserProfileCommand");
6685
- var de_GetUserProfileCommandError = /* @__PURE__ */ __name(async (output, context) => {
6686
- const parsedOutput = {
6687
- ...output,
6688
- body: await parseErrorBody(output.body, context)
6689
- };
6690
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6691
- switch (errorCode) {
6692
- case "AccessDeniedException":
6693
- case "com.amazonaws.datazone#AccessDeniedException":
6694
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6695
- case "InternalServerException":
6696
- case "com.amazonaws.datazone#InternalServerException":
6697
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6698
- case "ResourceNotFoundException":
6699
- case "com.amazonaws.datazone#ResourceNotFoundException":
6700
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6701
- case "ThrottlingException":
6702
- case "com.amazonaws.datazone#ThrottlingException":
6703
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6704
- case "UnauthorizedException":
6705
- case "com.amazonaws.datazone#UnauthorizedException":
6706
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6707
- case "ValidationException":
6708
- case "com.amazonaws.datazone#ValidationException":
6709
- throw await de_ValidationExceptionRes(parsedOutput, context);
6710
- default:
6711
- const parsedBody = parsedOutput.body;
6712
- return throwDefaultError({
6713
- output,
6714
- parsedBody,
6715
- errorCode
6716
- });
6717
- }
6718
- }, "de_GetUserProfileCommandError");
6719
4621
  var de_ListAssetRevisionsCommand = /* @__PURE__ */ __name(async (output, context) => {
6720
4622
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6721
- return de_ListAssetRevisionsCommandError(output, context);
4623
+ return de_CommandError(output, context);
6722
4624
  }
6723
4625
  const contents = (0, import_smithy_client.map)({
6724
4626
  $metadata: deserializeMetadata(output)
@@ -6731,153 +4633,39 @@ var de_ListAssetRevisionsCommand = /* @__PURE__ */ __name(async (output, context
6731
4633
  Object.assign(contents, doc);
6732
4634
  return contents;
6733
4635
  }, "de_ListAssetRevisionsCommand");
6734
- var de_ListAssetRevisionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
6735
- const parsedOutput = {
6736
- ...output,
6737
- body: await parseErrorBody(output.body, context)
6738
- };
6739
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6740
- switch (errorCode) {
6741
- case "AccessDeniedException":
6742
- case "com.amazonaws.datazone#AccessDeniedException":
6743
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6744
- case "InternalServerException":
6745
- case "com.amazonaws.datazone#InternalServerException":
6746
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6747
- case "ResourceNotFoundException":
6748
- case "com.amazonaws.datazone#ResourceNotFoundException":
6749
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6750
- case "ThrottlingException":
6751
- case "com.amazonaws.datazone#ThrottlingException":
6752
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6753
- case "UnauthorizedException":
6754
- case "com.amazonaws.datazone#UnauthorizedException":
6755
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6756
- case "ValidationException":
6757
- case "com.amazonaws.datazone#ValidationException":
6758
- throw await de_ValidationExceptionRes(parsedOutput, context);
6759
- default:
6760
- const parsedBody = parsedOutput.body;
6761
- return throwDefaultError({
6762
- output,
6763
- parsedBody,
6764
- errorCode
6765
- });
6766
- }
6767
- }, "de_ListAssetRevisionsCommandError");
6768
4636
  var de_ListDataSourceRunActivitiesCommand = /* @__PURE__ */ __name(async (output, context) => {
6769
- if (output.statusCode !== 200 && output.statusCode >= 300) {
6770
- return de_ListDataSourceRunActivitiesCommandError(output, context);
6771
- }
6772
- const contents = (0, import_smithy_client.map)({
6773
- $metadata: deserializeMetadata(output)
6774
- });
6775
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
6776
- const doc = (0, import_smithy_client.take)(data, {
6777
- items: (_) => de_DataSourceRunActivities(_, context),
6778
- nextToken: import_smithy_client.expectString
6779
- });
6780
- Object.assign(contents, doc);
6781
- return contents;
6782
- }, "de_ListDataSourceRunActivitiesCommand");
6783
- var de_ListDataSourceRunActivitiesCommandError = /* @__PURE__ */ __name(async (output, context) => {
6784
- const parsedOutput = {
6785
- ...output,
6786
- body: await parseErrorBody(output.body, context)
6787
- };
6788
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6789
- switch (errorCode) {
6790
- case "AccessDeniedException":
6791
- case "com.amazonaws.datazone#AccessDeniedException":
6792
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6793
- case "ConflictException":
6794
- case "com.amazonaws.datazone#ConflictException":
6795
- throw await de_ConflictExceptionRes(parsedOutput, context);
6796
- case "InternalServerException":
6797
- case "com.amazonaws.datazone#InternalServerException":
6798
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6799
- case "ResourceNotFoundException":
6800
- case "com.amazonaws.datazone#ResourceNotFoundException":
6801
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6802
- case "ServiceQuotaExceededException":
6803
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
6804
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
6805
- case "ThrottlingException":
6806
- case "com.amazonaws.datazone#ThrottlingException":
6807
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6808
- case "UnauthorizedException":
6809
- case "com.amazonaws.datazone#UnauthorizedException":
6810
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6811
- case "ValidationException":
6812
- case "com.amazonaws.datazone#ValidationException":
6813
- throw await de_ValidationExceptionRes(parsedOutput, context);
6814
- default:
6815
- const parsedBody = parsedOutput.body;
6816
- return throwDefaultError({
6817
- output,
6818
- parsedBody,
6819
- errorCode
6820
- });
6821
- }
6822
- }, "de_ListDataSourceRunActivitiesCommandError");
6823
- var de_ListDataSourceRunsCommand = /* @__PURE__ */ __name(async (output, context) => {
6824
- if (output.statusCode !== 200 && output.statusCode >= 300) {
6825
- return de_ListDataSourceRunsCommandError(output, context);
6826
- }
6827
- const contents = (0, import_smithy_client.map)({
6828
- $metadata: deserializeMetadata(output)
6829
- });
6830
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
6831
- const doc = (0, import_smithy_client.take)(data, {
6832
- items: (_) => de_DataSourceRunSummaries(_, context),
6833
- nextToken: import_smithy_client.expectString
6834
- });
6835
- Object.assign(contents, doc);
6836
- return contents;
6837
- }, "de_ListDataSourceRunsCommand");
6838
- var de_ListDataSourceRunsCommandError = /* @__PURE__ */ __name(async (output, context) => {
6839
- const parsedOutput = {
6840
- ...output,
6841
- body: await parseErrorBody(output.body, context)
6842
- };
6843
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6844
- switch (errorCode) {
6845
- case "AccessDeniedException":
6846
- case "com.amazonaws.datazone#AccessDeniedException":
6847
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6848
- case "ConflictException":
6849
- case "com.amazonaws.datazone#ConflictException":
6850
- throw await de_ConflictExceptionRes(parsedOutput, context);
6851
- case "InternalServerException":
6852
- case "com.amazonaws.datazone#InternalServerException":
6853
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6854
- case "ResourceNotFoundException":
6855
- case "com.amazonaws.datazone#ResourceNotFoundException":
6856
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6857
- case "ServiceQuotaExceededException":
6858
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
6859
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
6860
- case "ThrottlingException":
6861
- case "com.amazonaws.datazone#ThrottlingException":
6862
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6863
- case "UnauthorizedException":
6864
- case "com.amazonaws.datazone#UnauthorizedException":
6865
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6866
- case "ValidationException":
6867
- case "com.amazonaws.datazone#ValidationException":
6868
- throw await de_ValidationExceptionRes(parsedOutput, context);
6869
- default:
6870
- const parsedBody = parsedOutput.body;
6871
- return throwDefaultError({
6872
- output,
6873
- parsedBody,
6874
- errorCode
6875
- });
4637
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
4638
+ return de_CommandError(output, context);
4639
+ }
4640
+ const contents = (0, import_smithy_client.map)({
4641
+ $metadata: deserializeMetadata(output)
4642
+ });
4643
+ const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
4644
+ const doc = (0, import_smithy_client.take)(data, {
4645
+ items: (_) => de_DataSourceRunActivities(_, context),
4646
+ nextToken: import_smithy_client.expectString
4647
+ });
4648
+ Object.assign(contents, doc);
4649
+ return contents;
4650
+ }, "de_ListDataSourceRunActivitiesCommand");
4651
+ var de_ListDataSourceRunsCommand = /* @__PURE__ */ __name(async (output, context) => {
4652
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
4653
+ return de_CommandError(output, context);
6876
4654
  }
6877
- }, "de_ListDataSourceRunsCommandError");
4655
+ const contents = (0, import_smithy_client.map)({
4656
+ $metadata: deserializeMetadata(output)
4657
+ });
4658
+ const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
4659
+ const doc = (0, import_smithy_client.take)(data, {
4660
+ items: (_) => de_DataSourceRunSummaries(_, context),
4661
+ nextToken: import_smithy_client.expectString
4662
+ });
4663
+ Object.assign(contents, doc);
4664
+ return contents;
4665
+ }, "de_ListDataSourceRunsCommand");
6878
4666
  var de_ListDataSourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
6879
4667
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6880
- return de_ListDataSourcesCommandError(output, context);
4668
+ return de_CommandError(output, context);
6881
4669
  }
6882
4670
  const contents = (0, import_smithy_client.map)({
6883
4671
  $metadata: deserializeMetadata(output)
@@ -6890,49 +4678,9 @@ var de_ListDataSourcesCommand = /* @__PURE__ */ __name(async (output, context) =
6890
4678
  Object.assign(contents, doc);
6891
4679
  return contents;
6892
4680
  }, "de_ListDataSourcesCommand");
6893
- var de_ListDataSourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
6894
- const parsedOutput = {
6895
- ...output,
6896
- body: await parseErrorBody(output.body, context)
6897
- };
6898
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6899
- switch (errorCode) {
6900
- case "AccessDeniedException":
6901
- case "com.amazonaws.datazone#AccessDeniedException":
6902
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6903
- case "ConflictException":
6904
- case "com.amazonaws.datazone#ConflictException":
6905
- throw await de_ConflictExceptionRes(parsedOutput, context);
6906
- case "InternalServerException":
6907
- case "com.amazonaws.datazone#InternalServerException":
6908
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6909
- case "ResourceNotFoundException":
6910
- case "com.amazonaws.datazone#ResourceNotFoundException":
6911
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6912
- case "ServiceQuotaExceededException":
6913
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
6914
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
6915
- case "ThrottlingException":
6916
- case "com.amazonaws.datazone#ThrottlingException":
6917
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6918
- case "UnauthorizedException":
6919
- case "com.amazonaws.datazone#UnauthorizedException":
6920
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6921
- case "ValidationException":
6922
- case "com.amazonaws.datazone#ValidationException":
6923
- throw await de_ValidationExceptionRes(parsedOutput, context);
6924
- default:
6925
- const parsedBody = parsedOutput.body;
6926
- return throwDefaultError({
6927
- output,
6928
- parsedBody,
6929
- errorCode
6930
- });
6931
- }
6932
- }, "de_ListDataSourcesCommandError");
6933
4681
  var de_ListDomainsCommand = /* @__PURE__ */ __name(async (output, context) => {
6934
4682
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6935
- return de_ListDomainsCommandError(output, context);
4683
+ return de_CommandError(output, context);
6936
4684
  }
6937
4685
  const contents = (0, import_smithy_client.map)({
6938
4686
  $metadata: deserializeMetadata(output)
@@ -6945,49 +4693,9 @@ var de_ListDomainsCommand = /* @__PURE__ */ __name(async (output, context) => {
6945
4693
  Object.assign(contents, doc);
6946
4694
  return contents;
6947
4695
  }, "de_ListDomainsCommand");
6948
- var de_ListDomainsCommandError = /* @__PURE__ */ __name(async (output, context) => {
6949
- const parsedOutput = {
6950
- ...output,
6951
- body: await parseErrorBody(output.body, context)
6952
- };
6953
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
6954
- switch (errorCode) {
6955
- case "AccessDeniedException":
6956
- case "com.amazonaws.datazone#AccessDeniedException":
6957
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
6958
- case "ConflictException":
6959
- case "com.amazonaws.datazone#ConflictException":
6960
- throw await de_ConflictExceptionRes(parsedOutput, context);
6961
- case "InternalServerException":
6962
- case "com.amazonaws.datazone#InternalServerException":
6963
- throw await de_InternalServerExceptionRes(parsedOutput, context);
6964
- case "ResourceNotFoundException":
6965
- case "com.amazonaws.datazone#ResourceNotFoundException":
6966
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
6967
- case "ServiceQuotaExceededException":
6968
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
6969
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
6970
- case "ThrottlingException":
6971
- case "com.amazonaws.datazone#ThrottlingException":
6972
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
6973
- case "UnauthorizedException":
6974
- case "com.amazonaws.datazone#UnauthorizedException":
6975
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
6976
- case "ValidationException":
6977
- case "com.amazonaws.datazone#ValidationException":
6978
- throw await de_ValidationExceptionRes(parsedOutput, context);
6979
- default:
6980
- const parsedBody = parsedOutput.body;
6981
- return throwDefaultError({
6982
- output,
6983
- parsedBody,
6984
- errorCode
6985
- });
6986
- }
6987
- }, "de_ListDomainsCommandError");
6988
4696
  var de_ListEnvironmentBlueprintConfigurationsCommand = /* @__PURE__ */ __name(async (output, context) => {
6989
4697
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6990
- return de_ListEnvironmentBlueprintConfigurationsCommandError(output, context);
4698
+ return de_CommandError(output, context);
6991
4699
  }
6992
4700
  const contents = (0, import_smithy_client.map)({
6993
4701
  $metadata: deserializeMetadata(output)
@@ -7000,43 +4708,9 @@ var de_ListEnvironmentBlueprintConfigurationsCommand = /* @__PURE__ */ __name(as
7000
4708
  Object.assign(contents, doc);
7001
4709
  return contents;
7002
4710
  }, "de_ListEnvironmentBlueprintConfigurationsCommand");
7003
- var de_ListEnvironmentBlueprintConfigurationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
7004
- const parsedOutput = {
7005
- ...output,
7006
- body: await parseErrorBody(output.body, context)
7007
- };
7008
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7009
- switch (errorCode) {
7010
- case "AccessDeniedException":
7011
- case "com.amazonaws.datazone#AccessDeniedException":
7012
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7013
- case "InternalServerException":
7014
- case "com.amazonaws.datazone#InternalServerException":
7015
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7016
- case "ResourceNotFoundException":
7017
- case "com.amazonaws.datazone#ResourceNotFoundException":
7018
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
7019
- case "ThrottlingException":
7020
- case "com.amazonaws.datazone#ThrottlingException":
7021
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7022
- case "UnauthorizedException":
7023
- case "com.amazonaws.datazone#UnauthorizedException":
7024
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7025
- case "ValidationException":
7026
- case "com.amazonaws.datazone#ValidationException":
7027
- throw await de_ValidationExceptionRes(parsedOutput, context);
7028
- default:
7029
- const parsedBody = parsedOutput.body;
7030
- return throwDefaultError({
7031
- output,
7032
- parsedBody,
7033
- errorCode
7034
- });
7035
- }
7036
- }, "de_ListEnvironmentBlueprintConfigurationsCommandError");
7037
4711
  var de_ListEnvironmentBlueprintsCommand = /* @__PURE__ */ __name(async (output, context) => {
7038
4712
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7039
- return de_ListEnvironmentBlueprintsCommandError(output, context);
4713
+ return de_CommandError(output, context);
7040
4714
  }
7041
4715
  const contents = (0, import_smithy_client.map)({
7042
4716
  $metadata: deserializeMetadata(output)
@@ -7049,43 +4723,9 @@ var de_ListEnvironmentBlueprintsCommand = /* @__PURE__ */ __name(async (output,
7049
4723
  Object.assign(contents, doc);
7050
4724
  return contents;
7051
4725
  }, "de_ListEnvironmentBlueprintsCommand");
7052
- var de_ListEnvironmentBlueprintsCommandError = /* @__PURE__ */ __name(async (output, context) => {
7053
- const parsedOutput = {
7054
- ...output,
7055
- body: await parseErrorBody(output.body, context)
7056
- };
7057
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7058
- switch (errorCode) {
7059
- case "AccessDeniedException":
7060
- case "com.amazonaws.datazone#AccessDeniedException":
7061
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7062
- case "InternalServerException":
7063
- case "com.amazonaws.datazone#InternalServerException":
7064
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7065
- case "ResourceNotFoundException":
7066
- case "com.amazonaws.datazone#ResourceNotFoundException":
7067
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
7068
- case "ThrottlingException":
7069
- case "com.amazonaws.datazone#ThrottlingException":
7070
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7071
- case "UnauthorizedException":
7072
- case "com.amazonaws.datazone#UnauthorizedException":
7073
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7074
- case "ValidationException":
7075
- case "com.amazonaws.datazone#ValidationException":
7076
- throw await de_ValidationExceptionRes(parsedOutput, context);
7077
- default:
7078
- const parsedBody = parsedOutput.body;
7079
- return throwDefaultError({
7080
- output,
7081
- parsedBody,
7082
- errorCode
7083
- });
7084
- }
7085
- }, "de_ListEnvironmentBlueprintsCommandError");
7086
4726
  var de_ListEnvironmentProfilesCommand = /* @__PURE__ */ __name(async (output, context) => {
7087
4727
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7088
- return de_ListEnvironmentProfilesCommandError(output, context);
4728
+ return de_CommandError(output, context);
7089
4729
  }
7090
4730
  const contents = (0, import_smithy_client.map)({
7091
4731
  $metadata: deserializeMetadata(output)
@@ -7098,40 +4738,9 @@ var de_ListEnvironmentProfilesCommand = /* @__PURE__ */ __name(async (output, co
7098
4738
  Object.assign(contents, doc);
7099
4739
  return contents;
7100
4740
  }, "de_ListEnvironmentProfilesCommand");
7101
- var de_ListEnvironmentProfilesCommandError = /* @__PURE__ */ __name(async (output, context) => {
7102
- const parsedOutput = {
7103
- ...output,
7104
- body: await parseErrorBody(output.body, context)
7105
- };
7106
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7107
- switch (errorCode) {
7108
- case "AccessDeniedException":
7109
- case "com.amazonaws.datazone#AccessDeniedException":
7110
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7111
- case "InternalServerException":
7112
- case "com.amazonaws.datazone#InternalServerException":
7113
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7114
- case "ThrottlingException":
7115
- case "com.amazonaws.datazone#ThrottlingException":
7116
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7117
- case "UnauthorizedException":
7118
- case "com.amazonaws.datazone#UnauthorizedException":
7119
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7120
- case "ValidationException":
7121
- case "com.amazonaws.datazone#ValidationException":
7122
- throw await de_ValidationExceptionRes(parsedOutput, context);
7123
- default:
7124
- const parsedBody = parsedOutput.body;
7125
- return throwDefaultError({
7126
- output,
7127
- parsedBody,
7128
- errorCode
7129
- });
7130
- }
7131
- }, "de_ListEnvironmentProfilesCommandError");
7132
4741
  var de_ListEnvironmentsCommand = /* @__PURE__ */ __name(async (output, context) => {
7133
4742
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7134
- return de_ListEnvironmentsCommandError(output, context);
4743
+ return de_CommandError(output, context);
7135
4744
  }
7136
4745
  const contents = (0, import_smithy_client.map)({
7137
4746
  $metadata: deserializeMetadata(output)
@@ -7144,40 +4753,9 @@ var de_ListEnvironmentsCommand = /* @__PURE__ */ __name(async (output, context)
7144
4753
  Object.assign(contents, doc);
7145
4754
  return contents;
7146
4755
  }, "de_ListEnvironmentsCommand");
7147
- var de_ListEnvironmentsCommandError = /* @__PURE__ */ __name(async (output, context) => {
7148
- const parsedOutput = {
7149
- ...output,
7150
- body: await parseErrorBody(output.body, context)
7151
- };
7152
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7153
- switch (errorCode) {
7154
- case "AccessDeniedException":
7155
- case "com.amazonaws.datazone#AccessDeniedException":
7156
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7157
- case "InternalServerException":
7158
- case "com.amazonaws.datazone#InternalServerException":
7159
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7160
- case "ThrottlingException":
7161
- case "com.amazonaws.datazone#ThrottlingException":
7162
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7163
- case "UnauthorizedException":
7164
- case "com.amazonaws.datazone#UnauthorizedException":
7165
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7166
- case "ValidationException":
7167
- case "com.amazonaws.datazone#ValidationException":
7168
- throw await de_ValidationExceptionRes(parsedOutput, context);
7169
- default:
7170
- const parsedBody = parsedOutput.body;
7171
- return throwDefaultError({
7172
- output,
7173
- parsedBody,
7174
- errorCode
7175
- });
7176
- }
7177
- }, "de_ListEnvironmentsCommandError");
7178
4756
  var de_ListNotificationsCommand = /* @__PURE__ */ __name(async (output, context) => {
7179
4757
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7180
- return de_ListNotificationsCommandError(output, context);
4758
+ return de_CommandError(output, context);
7181
4759
  }
7182
4760
  const contents = (0, import_smithy_client.map)({
7183
4761
  $metadata: deserializeMetadata(output)
@@ -7190,43 +4768,9 @@ var de_ListNotificationsCommand = /* @__PURE__ */ __name(async (output, context)
7190
4768
  Object.assign(contents, doc);
7191
4769
  return contents;
7192
4770
  }, "de_ListNotificationsCommand");
7193
- var de_ListNotificationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
7194
- const parsedOutput = {
7195
- ...output,
7196
- body: await parseErrorBody(output.body, context)
7197
- };
7198
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7199
- switch (errorCode) {
7200
- case "AccessDeniedException":
7201
- case "com.amazonaws.datazone#AccessDeniedException":
7202
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7203
- case "InternalServerException":
7204
- case "com.amazonaws.datazone#InternalServerException":
7205
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7206
- case "ResourceNotFoundException":
7207
- case "com.amazonaws.datazone#ResourceNotFoundException":
7208
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
7209
- case "ThrottlingException":
7210
- case "com.amazonaws.datazone#ThrottlingException":
7211
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7212
- case "UnauthorizedException":
7213
- case "com.amazonaws.datazone#UnauthorizedException":
7214
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7215
- case "ValidationException":
7216
- case "com.amazonaws.datazone#ValidationException":
7217
- throw await de_ValidationExceptionRes(parsedOutput, context);
7218
- default:
7219
- const parsedBody = parsedOutput.body;
7220
- return throwDefaultError({
7221
- output,
7222
- parsedBody,
7223
- errorCode
7224
- });
7225
- }
7226
- }, "de_ListNotificationsCommandError");
7227
4771
  var de_ListProjectMembershipsCommand = /* @__PURE__ */ __name(async (output, context) => {
7228
4772
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7229
- return de_ListProjectMembershipsCommandError(output, context);
4773
+ return de_CommandError(output, context);
7230
4774
  }
7231
4775
  const contents = (0, import_smithy_client.map)({
7232
4776
  $metadata: deserializeMetadata(output)
@@ -7239,43 +4783,9 @@ var de_ListProjectMembershipsCommand = /* @__PURE__ */ __name(async (output, con
7239
4783
  Object.assign(contents, doc);
7240
4784
  return contents;
7241
4785
  }, "de_ListProjectMembershipsCommand");
7242
- var de_ListProjectMembershipsCommandError = /* @__PURE__ */ __name(async (output, context) => {
7243
- const parsedOutput = {
7244
- ...output,
7245
- body: await parseErrorBody(output.body, context)
7246
- };
7247
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7248
- switch (errorCode) {
7249
- case "AccessDeniedException":
7250
- case "com.amazonaws.datazone#AccessDeniedException":
7251
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7252
- case "InternalServerException":
7253
- case "com.amazonaws.datazone#InternalServerException":
7254
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7255
- case "ResourceNotFoundException":
7256
- case "com.amazonaws.datazone#ResourceNotFoundException":
7257
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
7258
- case "ThrottlingException":
7259
- case "com.amazonaws.datazone#ThrottlingException":
7260
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7261
- case "UnauthorizedException":
7262
- case "com.amazonaws.datazone#UnauthorizedException":
7263
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7264
- case "ValidationException":
7265
- case "com.amazonaws.datazone#ValidationException":
7266
- throw await de_ValidationExceptionRes(parsedOutput, context);
7267
- default:
7268
- const parsedBody = parsedOutput.body;
7269
- return throwDefaultError({
7270
- output,
7271
- parsedBody,
7272
- errorCode
7273
- });
7274
- }
7275
- }, "de_ListProjectMembershipsCommandError");
7276
4786
  var de_ListProjectsCommand = /* @__PURE__ */ __name(async (output, context) => {
7277
4787
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7278
- return de_ListProjectsCommandError(output, context);
4788
+ return de_CommandError(output, context);
7279
4789
  }
7280
4790
  const contents = (0, import_smithy_client.map)({
7281
4791
  $metadata: deserializeMetadata(output)
@@ -7288,40 +4798,9 @@ var de_ListProjectsCommand = /* @__PURE__ */ __name(async (output, context) => {
7288
4798
  Object.assign(contents, doc);
7289
4799
  return contents;
7290
4800
  }, "de_ListProjectsCommand");
7291
- var de_ListProjectsCommandError = /* @__PURE__ */ __name(async (output, context) => {
7292
- const parsedOutput = {
7293
- ...output,
7294
- body: await parseErrorBody(output.body, context)
7295
- };
7296
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7297
- switch (errorCode) {
7298
- case "AccessDeniedException":
7299
- case "com.amazonaws.datazone#AccessDeniedException":
7300
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7301
- case "InternalServerException":
7302
- case "com.amazonaws.datazone#InternalServerException":
7303
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7304
- case "ThrottlingException":
7305
- case "com.amazonaws.datazone#ThrottlingException":
7306
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7307
- case "UnauthorizedException":
7308
- case "com.amazonaws.datazone#UnauthorizedException":
7309
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7310
- case "ValidationException":
7311
- case "com.amazonaws.datazone#ValidationException":
7312
- throw await de_ValidationExceptionRes(parsedOutput, context);
7313
- default:
7314
- const parsedBody = parsedOutput.body;
7315
- return throwDefaultError({
7316
- output,
7317
- parsedBody,
7318
- errorCode
7319
- });
7320
- }
7321
- }, "de_ListProjectsCommandError");
7322
4801
  var de_ListSubscriptionGrantsCommand = /* @__PURE__ */ __name(async (output, context) => {
7323
4802
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7324
- return de_ListSubscriptionGrantsCommandError(output, context);
4803
+ return de_CommandError(output, context);
7325
4804
  }
7326
4805
  const contents = (0, import_smithy_client.map)({
7327
4806
  $metadata: deserializeMetadata(output)
@@ -7334,43 +4813,9 @@ var de_ListSubscriptionGrantsCommand = /* @__PURE__ */ __name(async (output, con
7334
4813
  Object.assign(contents, doc);
7335
4814
  return contents;
7336
4815
  }, "de_ListSubscriptionGrantsCommand");
7337
- var de_ListSubscriptionGrantsCommandError = /* @__PURE__ */ __name(async (output, context) => {
7338
- const parsedOutput = {
7339
- ...output,
7340
- body: await parseErrorBody(output.body, context)
7341
- };
7342
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7343
- switch (errorCode) {
7344
- case "AccessDeniedException":
7345
- case "com.amazonaws.datazone#AccessDeniedException":
7346
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7347
- case "InternalServerException":
7348
- case "com.amazonaws.datazone#InternalServerException":
7349
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7350
- case "ResourceNotFoundException":
7351
- case "com.amazonaws.datazone#ResourceNotFoundException":
7352
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
7353
- case "ThrottlingException":
7354
- case "com.amazonaws.datazone#ThrottlingException":
7355
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7356
- case "UnauthorizedException":
7357
- case "com.amazonaws.datazone#UnauthorizedException":
7358
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7359
- case "ValidationException":
7360
- case "com.amazonaws.datazone#ValidationException":
7361
- throw await de_ValidationExceptionRes(parsedOutput, context);
7362
- default:
7363
- const parsedBody = parsedOutput.body;
7364
- return throwDefaultError({
7365
- output,
7366
- parsedBody,
7367
- errorCode
7368
- });
7369
- }
7370
- }, "de_ListSubscriptionGrantsCommandError");
7371
4816
  var de_ListSubscriptionRequestsCommand = /* @__PURE__ */ __name(async (output, context) => {
7372
4817
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7373
- return de_ListSubscriptionRequestsCommandError(output, context);
4818
+ return de_CommandError(output, context);
7374
4819
  }
7375
4820
  const contents = (0, import_smithy_client.map)({
7376
4821
  $metadata: deserializeMetadata(output)
@@ -7383,43 +4828,9 @@ var de_ListSubscriptionRequestsCommand = /* @__PURE__ */ __name(async (output, c
7383
4828
  Object.assign(contents, doc);
7384
4829
  return contents;
7385
4830
  }, "de_ListSubscriptionRequestsCommand");
7386
- var de_ListSubscriptionRequestsCommandError = /* @__PURE__ */ __name(async (output, context) => {
7387
- const parsedOutput = {
7388
- ...output,
7389
- body: await parseErrorBody(output.body, context)
7390
- };
7391
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7392
- switch (errorCode) {
7393
- case "AccessDeniedException":
7394
- case "com.amazonaws.datazone#AccessDeniedException":
7395
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7396
- case "InternalServerException":
7397
- case "com.amazonaws.datazone#InternalServerException":
7398
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7399
- case "ResourceNotFoundException":
7400
- case "com.amazonaws.datazone#ResourceNotFoundException":
7401
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
7402
- case "ThrottlingException":
7403
- case "com.amazonaws.datazone#ThrottlingException":
7404
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7405
- case "UnauthorizedException":
7406
- case "com.amazonaws.datazone#UnauthorizedException":
7407
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7408
- case "ValidationException":
7409
- case "com.amazonaws.datazone#ValidationException":
7410
- throw await de_ValidationExceptionRes(parsedOutput, context);
7411
- default:
7412
- const parsedBody = parsedOutput.body;
7413
- return throwDefaultError({
7414
- output,
7415
- parsedBody,
7416
- errorCode
7417
- });
7418
- }
7419
- }, "de_ListSubscriptionRequestsCommandError");
7420
4831
  var de_ListSubscriptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
7421
4832
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7422
- return de_ListSubscriptionsCommandError(output, context);
4833
+ return de_CommandError(output, context);
7423
4834
  }
7424
4835
  const contents = (0, import_smithy_client.map)({
7425
4836
  $metadata: deserializeMetadata(output)
@@ -7432,43 +4843,9 @@ var de_ListSubscriptionsCommand = /* @__PURE__ */ __name(async (output, context)
7432
4843
  Object.assign(contents, doc);
7433
4844
  return contents;
7434
4845
  }, "de_ListSubscriptionsCommand");
7435
- var de_ListSubscriptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
7436
- const parsedOutput = {
7437
- ...output,
7438
- body: await parseErrorBody(output.body, context)
7439
- };
7440
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7441
- switch (errorCode) {
7442
- case "AccessDeniedException":
7443
- case "com.amazonaws.datazone#AccessDeniedException":
7444
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7445
- case "InternalServerException":
7446
- case "com.amazonaws.datazone#InternalServerException":
7447
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7448
- case "ResourceNotFoundException":
7449
- case "com.amazonaws.datazone#ResourceNotFoundException":
7450
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
7451
- case "ThrottlingException":
7452
- case "com.amazonaws.datazone#ThrottlingException":
7453
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7454
- case "UnauthorizedException":
7455
- case "com.amazonaws.datazone#UnauthorizedException":
7456
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7457
- case "ValidationException":
7458
- case "com.amazonaws.datazone#ValidationException":
7459
- throw await de_ValidationExceptionRes(parsedOutput, context);
7460
- default:
7461
- const parsedBody = parsedOutput.body;
7462
- return throwDefaultError({
7463
- output,
7464
- parsedBody,
7465
- errorCode
7466
- });
7467
- }
7468
- }, "de_ListSubscriptionsCommandError");
7469
4846
  var de_ListSubscriptionTargetsCommand = /* @__PURE__ */ __name(async (output, context) => {
7470
4847
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7471
- return de_ListSubscriptionTargetsCommandError(output, context);
4848
+ return de_CommandError(output, context);
7472
4849
  }
7473
4850
  const contents = (0, import_smithy_client.map)({
7474
4851
  $metadata: deserializeMetadata(output)
@@ -7481,43 +4858,9 @@ var de_ListSubscriptionTargetsCommand = /* @__PURE__ */ __name(async (output, co
7481
4858
  Object.assign(contents, doc);
7482
4859
  return contents;
7483
4860
  }, "de_ListSubscriptionTargetsCommand");
7484
- var de_ListSubscriptionTargetsCommandError = /* @__PURE__ */ __name(async (output, context) => {
7485
- const parsedOutput = {
7486
- ...output,
7487
- body: await parseErrorBody(output.body, context)
7488
- };
7489
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7490
- switch (errorCode) {
7491
- case "AccessDeniedException":
7492
- case "com.amazonaws.datazone#AccessDeniedException":
7493
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7494
- case "InternalServerException":
7495
- case "com.amazonaws.datazone#InternalServerException":
7496
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7497
- case "ResourceNotFoundException":
7498
- case "com.amazonaws.datazone#ResourceNotFoundException":
7499
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
7500
- case "ThrottlingException":
7501
- case "com.amazonaws.datazone#ThrottlingException":
7502
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7503
- case "UnauthorizedException":
7504
- case "com.amazonaws.datazone#UnauthorizedException":
7505
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7506
- case "ValidationException":
7507
- case "com.amazonaws.datazone#ValidationException":
7508
- throw await de_ValidationExceptionRes(parsedOutput, context);
7509
- default:
7510
- const parsedBody = parsedOutput.body;
7511
- return throwDefaultError({
7512
- output,
7513
- parsedBody,
7514
- errorCode
7515
- });
7516
- }
7517
- }, "de_ListSubscriptionTargetsCommandError");
7518
4861
  var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
7519
4862
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7520
- return de_ListTagsForResourceCommandError(output, context);
4863
+ return de_CommandError(output, context);
7521
4864
  }
7522
4865
  const contents = (0, import_smithy_client.map)({
7523
4866
  $metadata: deserializeMetadata(output)
@@ -7529,43 +4872,9 @@ var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, contex
7529
4872
  Object.assign(contents, doc);
7530
4873
  return contents;
7531
4874
  }, "de_ListTagsForResourceCommand");
7532
- var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
7533
- const parsedOutput = {
7534
- ...output,
7535
- body: await parseErrorBody(output.body, context)
7536
- };
7537
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7538
- switch (errorCode) {
7539
- case "AccessDeniedException":
7540
- case "com.amazonaws.datazone#AccessDeniedException":
7541
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7542
- case "InternalServerException":
7543
- case "com.amazonaws.datazone#InternalServerException":
7544
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7545
- case "ResourceNotFoundException":
7546
- case "com.amazonaws.datazone#ResourceNotFoundException":
7547
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
7548
- case "ThrottlingException":
7549
- case "com.amazonaws.datazone#ThrottlingException":
7550
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7551
- case "UnauthorizedException":
7552
- case "com.amazonaws.datazone#UnauthorizedException":
7553
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7554
- case "ValidationException":
7555
- case "com.amazonaws.datazone#ValidationException":
7556
- throw await de_ValidationExceptionRes(parsedOutput, context);
7557
- default:
7558
- const parsedBody = parsedOutput.body;
7559
- return throwDefaultError({
7560
- output,
7561
- parsedBody,
7562
- errorCode
7563
- });
7564
- }
7565
- }, "de_ListTagsForResourceCommandError");
7566
4875
  var de_PutEnvironmentBlueprintConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
7567
4876
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7568
- return de_PutEnvironmentBlueprintConfigurationCommandError(output, context);
4877
+ return de_CommandError(output, context);
7569
4878
  }
7570
4879
  const contents = (0, import_smithy_client.map)({
7571
4880
  $metadata: deserializeMetadata(output)
@@ -7584,46 +4893,9 @@ var de_PutEnvironmentBlueprintConfigurationCommand = /* @__PURE__ */ __name(asyn
7584
4893
  Object.assign(contents, doc);
7585
4894
  return contents;
7586
4895
  }, "de_PutEnvironmentBlueprintConfigurationCommand");
7587
- var de_PutEnvironmentBlueprintConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
7588
- const parsedOutput = {
7589
- ...output,
7590
- body: await parseErrorBody(output.body, context)
7591
- };
7592
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7593
- switch (errorCode) {
7594
- case "AccessDeniedException":
7595
- case "com.amazonaws.datazone#AccessDeniedException":
7596
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7597
- case "ConflictException":
7598
- case "com.amazonaws.datazone#ConflictException":
7599
- throw await de_ConflictExceptionRes(parsedOutput, context);
7600
- case "InternalServerException":
7601
- case "com.amazonaws.datazone#InternalServerException":
7602
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7603
- case "ResourceNotFoundException":
7604
- case "com.amazonaws.datazone#ResourceNotFoundException":
7605
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
7606
- case "ThrottlingException":
7607
- case "com.amazonaws.datazone#ThrottlingException":
7608
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7609
- case "UnauthorizedException":
7610
- case "com.amazonaws.datazone#UnauthorizedException":
7611
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7612
- case "ValidationException":
7613
- case "com.amazonaws.datazone#ValidationException":
7614
- throw await de_ValidationExceptionRes(parsedOutput, context);
7615
- default:
7616
- const parsedBody = parsedOutput.body;
7617
- return throwDefaultError({
7618
- output,
7619
- parsedBody,
7620
- errorCode
7621
- });
7622
- }
7623
- }, "de_PutEnvironmentBlueprintConfigurationCommandError");
7624
4896
  var de_RejectPredictionsCommand = /* @__PURE__ */ __name(async (output, context) => {
7625
4897
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7626
- return de_RejectPredictionsCommandError(output, context);
4898
+ return de_CommandError(output, context);
7627
4899
  }
7628
4900
  const contents = (0, import_smithy_client.map)({
7629
4901
  $metadata: deserializeMetadata(output)
@@ -7637,43 +4909,9 @@ var de_RejectPredictionsCommand = /* @__PURE__ */ __name(async (output, context)
7637
4909
  Object.assign(contents, doc);
7638
4910
  return contents;
7639
4911
  }, "de_RejectPredictionsCommand");
7640
- var de_RejectPredictionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
7641
- const parsedOutput = {
7642
- ...output,
7643
- body: await parseErrorBody(output.body, context)
7644
- };
7645
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7646
- switch (errorCode) {
7647
- case "AccessDeniedException":
7648
- case "com.amazonaws.datazone#AccessDeniedException":
7649
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7650
- case "InternalServerException":
7651
- case "com.amazonaws.datazone#InternalServerException":
7652
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7653
- case "ResourceNotFoundException":
7654
- case "com.amazonaws.datazone#ResourceNotFoundException":
7655
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
7656
- case "ThrottlingException":
7657
- case "com.amazonaws.datazone#ThrottlingException":
7658
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7659
- case "UnauthorizedException":
7660
- case "com.amazonaws.datazone#UnauthorizedException":
7661
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7662
- case "ValidationException":
7663
- case "com.amazonaws.datazone#ValidationException":
7664
- throw await de_ValidationExceptionRes(parsedOutput, context);
7665
- default:
7666
- const parsedBody = parsedOutput.body;
7667
- return throwDefaultError({
7668
- output,
7669
- parsedBody,
7670
- errorCode
7671
- });
7672
- }
7673
- }, "de_RejectPredictionsCommandError");
7674
4912
  var de_RejectSubscriptionRequestCommand = /* @__PURE__ */ __name(async (output, context) => {
7675
4913
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7676
- return de_RejectSubscriptionRequestCommandError(output, context);
4914
+ return de_CommandError(output, context);
7677
4915
  }
7678
4916
  const contents = (0, import_smithy_client.map)({
7679
4917
  $metadata: deserializeMetadata(output)
@@ -7696,46 +4934,9 @@ var de_RejectSubscriptionRequestCommand = /* @__PURE__ */ __name(async (output,
7696
4934
  Object.assign(contents, doc);
7697
4935
  return contents;
7698
4936
  }, "de_RejectSubscriptionRequestCommand");
7699
- var de_RejectSubscriptionRequestCommandError = /* @__PURE__ */ __name(async (output, context) => {
7700
- const parsedOutput = {
7701
- ...output,
7702
- body: await parseErrorBody(output.body, context)
7703
- };
7704
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7705
- switch (errorCode) {
7706
- case "AccessDeniedException":
7707
- case "com.amazonaws.datazone#AccessDeniedException":
7708
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7709
- case "ConflictException":
7710
- case "com.amazonaws.datazone#ConflictException":
7711
- throw await de_ConflictExceptionRes(parsedOutput, context);
7712
- case "InternalServerException":
7713
- case "com.amazonaws.datazone#InternalServerException":
7714
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7715
- case "ResourceNotFoundException":
7716
- case "com.amazonaws.datazone#ResourceNotFoundException":
7717
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
7718
- case "ThrottlingException":
7719
- case "com.amazonaws.datazone#ThrottlingException":
7720
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7721
- case "UnauthorizedException":
7722
- case "com.amazonaws.datazone#UnauthorizedException":
7723
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7724
- case "ValidationException":
7725
- case "com.amazonaws.datazone#ValidationException":
7726
- throw await de_ValidationExceptionRes(parsedOutput, context);
7727
- default:
7728
- const parsedBody = parsedOutput.body;
7729
- return throwDefaultError({
7730
- output,
7731
- parsedBody,
7732
- errorCode
7733
- });
7734
- }
7735
- }, "de_RejectSubscriptionRequestCommandError");
7736
4937
  var de_RevokeSubscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
7737
4938
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7738
- return de_RevokeSubscriptionCommandError(output, context);
4939
+ return de_CommandError(output, context);
7739
4940
  }
7740
4941
  const contents = (0, import_smithy_client.map)({
7741
4942
  $metadata: deserializeMetadata(output)
@@ -7757,46 +4958,9 @@ var de_RevokeSubscriptionCommand = /* @__PURE__ */ __name(async (output, context
7757
4958
  Object.assign(contents, doc);
7758
4959
  return contents;
7759
4960
  }, "de_RevokeSubscriptionCommand");
7760
- var de_RevokeSubscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
7761
- const parsedOutput = {
7762
- ...output,
7763
- body: await parseErrorBody(output.body, context)
7764
- };
7765
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7766
- switch (errorCode) {
7767
- case "AccessDeniedException":
7768
- case "com.amazonaws.datazone#AccessDeniedException":
7769
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7770
- case "ConflictException":
7771
- case "com.amazonaws.datazone#ConflictException":
7772
- throw await de_ConflictExceptionRes(parsedOutput, context);
7773
- case "InternalServerException":
7774
- case "com.amazonaws.datazone#InternalServerException":
7775
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7776
- case "ResourceNotFoundException":
7777
- case "com.amazonaws.datazone#ResourceNotFoundException":
7778
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
7779
- case "ThrottlingException":
7780
- case "com.amazonaws.datazone#ThrottlingException":
7781
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7782
- case "UnauthorizedException":
7783
- case "com.amazonaws.datazone#UnauthorizedException":
7784
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7785
- case "ValidationException":
7786
- case "com.amazonaws.datazone#ValidationException":
7787
- throw await de_ValidationExceptionRes(parsedOutput, context);
7788
- default:
7789
- const parsedBody = parsedOutput.body;
7790
- return throwDefaultError({
7791
- output,
7792
- parsedBody,
7793
- errorCode
7794
- });
7795
- }
7796
- }, "de_RevokeSubscriptionCommandError");
7797
4961
  var de_SearchCommand = /* @__PURE__ */ __name(async (output, context) => {
7798
4962
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7799
- return de_SearchCommandError(output, context);
4963
+ return de_CommandError(output, context);
7800
4964
  }
7801
4965
  const contents = (0, import_smithy_client.map)({
7802
4966
  $metadata: deserializeMetadata(output)
@@ -7810,40 +4974,9 @@ var de_SearchCommand = /* @__PURE__ */ __name(async (output, context) => {
7810
4974
  Object.assign(contents, doc);
7811
4975
  return contents;
7812
4976
  }, "de_SearchCommand");
7813
- var de_SearchCommandError = /* @__PURE__ */ __name(async (output, context) => {
7814
- const parsedOutput = {
7815
- ...output,
7816
- body: await parseErrorBody(output.body, context)
7817
- };
7818
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7819
- switch (errorCode) {
7820
- case "AccessDeniedException":
7821
- case "com.amazonaws.datazone#AccessDeniedException":
7822
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7823
- case "InternalServerException":
7824
- case "com.amazonaws.datazone#InternalServerException":
7825
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7826
- case "ThrottlingException":
7827
- case "com.amazonaws.datazone#ThrottlingException":
7828
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7829
- case "UnauthorizedException":
7830
- case "com.amazonaws.datazone#UnauthorizedException":
7831
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7832
- case "ValidationException":
7833
- case "com.amazonaws.datazone#ValidationException":
7834
- throw await de_ValidationExceptionRes(parsedOutput, context);
7835
- default:
7836
- const parsedBody = parsedOutput.body;
7837
- return throwDefaultError({
7838
- output,
7839
- parsedBody,
7840
- errorCode
7841
- });
7842
- }
7843
- }, "de_SearchCommandError");
7844
4977
  var de_SearchGroupProfilesCommand = /* @__PURE__ */ __name(async (output, context) => {
7845
4978
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7846
- return de_SearchGroupProfilesCommandError(output, context);
4979
+ return de_CommandError(output, context);
7847
4980
  }
7848
4981
  const contents = (0, import_smithy_client.map)({
7849
4982
  $metadata: deserializeMetadata(output)
@@ -7856,43 +4989,9 @@ var de_SearchGroupProfilesCommand = /* @__PURE__ */ __name(async (output, contex
7856
4989
  Object.assign(contents, doc);
7857
4990
  return contents;
7858
4991
  }, "de_SearchGroupProfilesCommand");
7859
- var de_SearchGroupProfilesCommandError = /* @__PURE__ */ __name(async (output, context) => {
7860
- const parsedOutput = {
7861
- ...output,
7862
- body: await parseErrorBody(output.body, context)
7863
- };
7864
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7865
- switch (errorCode) {
7866
- case "AccessDeniedException":
7867
- case "com.amazonaws.datazone#AccessDeniedException":
7868
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7869
- case "InternalServerException":
7870
- case "com.amazonaws.datazone#InternalServerException":
7871
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7872
- case "ResourceNotFoundException":
7873
- case "com.amazonaws.datazone#ResourceNotFoundException":
7874
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
7875
- case "ThrottlingException":
7876
- case "com.amazonaws.datazone#ThrottlingException":
7877
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7878
- case "UnauthorizedException":
7879
- case "com.amazonaws.datazone#UnauthorizedException":
7880
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7881
- case "ValidationException":
7882
- case "com.amazonaws.datazone#ValidationException":
7883
- throw await de_ValidationExceptionRes(parsedOutput, context);
7884
- default:
7885
- const parsedBody = parsedOutput.body;
7886
- return throwDefaultError({
7887
- output,
7888
- parsedBody,
7889
- errorCode
7890
- });
7891
- }
7892
- }, "de_SearchGroupProfilesCommandError");
7893
4992
  var de_SearchListingsCommand = /* @__PURE__ */ __name(async (output, context) => {
7894
4993
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7895
- return de_SearchListingsCommandError(output, context);
4994
+ return de_CommandError(output, context);
7896
4995
  }
7897
4996
  const contents = (0, import_smithy_client.map)({
7898
4997
  $metadata: deserializeMetadata(output)
@@ -7906,40 +5005,9 @@ var de_SearchListingsCommand = /* @__PURE__ */ __name(async (output, context) =>
7906
5005
  Object.assign(contents, doc);
7907
5006
  return contents;
7908
5007
  }, "de_SearchListingsCommand");
7909
- var de_SearchListingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
7910
- const parsedOutput = {
7911
- ...output,
7912
- body: await parseErrorBody(output.body, context)
7913
- };
7914
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7915
- switch (errorCode) {
7916
- case "AccessDeniedException":
7917
- case "com.amazonaws.datazone#AccessDeniedException":
7918
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7919
- case "InternalServerException":
7920
- case "com.amazonaws.datazone#InternalServerException":
7921
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7922
- case "ThrottlingException":
7923
- case "com.amazonaws.datazone#ThrottlingException":
7924
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7925
- case "UnauthorizedException":
7926
- case "com.amazonaws.datazone#UnauthorizedException":
7927
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7928
- case "ValidationException":
7929
- case "com.amazonaws.datazone#ValidationException":
7930
- throw await de_ValidationExceptionRes(parsedOutput, context);
7931
- default:
7932
- const parsedBody = parsedOutput.body;
7933
- return throwDefaultError({
7934
- output,
7935
- parsedBody,
7936
- errorCode
7937
- });
7938
- }
7939
- }, "de_SearchListingsCommandError");
7940
5008
  var de_SearchTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
7941
5009
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7942
- return de_SearchTypesCommandError(output, context);
5010
+ return de_CommandError(output, context);
7943
5011
  }
7944
5012
  const contents = (0, import_smithy_client.map)({
7945
5013
  $metadata: deserializeMetadata(output)
@@ -7953,40 +5021,9 @@ var de_SearchTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
7953
5021
  Object.assign(contents, doc);
7954
5022
  return contents;
7955
5023
  }, "de_SearchTypesCommand");
7956
- var de_SearchTypesCommandError = /* @__PURE__ */ __name(async (output, context) => {
7957
- const parsedOutput = {
7958
- ...output,
7959
- body: await parseErrorBody(output.body, context)
7960
- };
7961
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
7962
- switch (errorCode) {
7963
- case "AccessDeniedException":
7964
- case "com.amazonaws.datazone#AccessDeniedException":
7965
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
7966
- case "InternalServerException":
7967
- case "com.amazonaws.datazone#InternalServerException":
7968
- throw await de_InternalServerExceptionRes(parsedOutput, context);
7969
- case "ThrottlingException":
7970
- case "com.amazonaws.datazone#ThrottlingException":
7971
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
7972
- case "UnauthorizedException":
7973
- case "com.amazonaws.datazone#UnauthorizedException":
7974
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
7975
- case "ValidationException":
7976
- case "com.amazonaws.datazone#ValidationException":
7977
- throw await de_ValidationExceptionRes(parsedOutput, context);
7978
- default:
7979
- const parsedBody = parsedOutput.body;
7980
- return throwDefaultError({
7981
- output,
7982
- parsedBody,
7983
- errorCode
7984
- });
7985
- }
7986
- }, "de_SearchTypesCommandError");
7987
5024
  var de_SearchUserProfilesCommand = /* @__PURE__ */ __name(async (output, context) => {
7988
5025
  if (output.statusCode !== 200 && output.statusCode >= 300) {
7989
- return de_SearchUserProfilesCommandError(output, context);
5026
+ return de_CommandError(output, context);
7990
5027
  }
7991
5028
  const contents = (0, import_smithy_client.map)({
7992
5029
  $metadata: deserializeMetadata(output)
@@ -7996,46 +5033,12 @@ var de_SearchUserProfilesCommand = /* @__PURE__ */ __name(async (output, context
7996
5033
  items: import_smithy_client._json,
7997
5034
  nextToken: import_smithy_client.expectString
7998
5035
  });
7999
- Object.assign(contents, doc);
8000
- return contents;
8001
- }, "de_SearchUserProfilesCommand");
8002
- var de_SearchUserProfilesCommandError = /* @__PURE__ */ __name(async (output, context) => {
8003
- const parsedOutput = {
8004
- ...output,
8005
- body: await parseErrorBody(output.body, context)
8006
- };
8007
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
8008
- switch (errorCode) {
8009
- case "AccessDeniedException":
8010
- case "com.amazonaws.datazone#AccessDeniedException":
8011
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
8012
- case "InternalServerException":
8013
- case "com.amazonaws.datazone#InternalServerException":
8014
- throw await de_InternalServerExceptionRes(parsedOutput, context);
8015
- case "ResourceNotFoundException":
8016
- case "com.amazonaws.datazone#ResourceNotFoundException":
8017
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
8018
- case "ThrottlingException":
8019
- case "com.amazonaws.datazone#ThrottlingException":
8020
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
8021
- case "UnauthorizedException":
8022
- case "com.amazonaws.datazone#UnauthorizedException":
8023
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
8024
- case "ValidationException":
8025
- case "com.amazonaws.datazone#ValidationException":
8026
- throw await de_ValidationExceptionRes(parsedOutput, context);
8027
- default:
8028
- const parsedBody = parsedOutput.body;
8029
- return throwDefaultError({
8030
- output,
8031
- parsedBody,
8032
- errorCode
8033
- });
8034
- }
8035
- }, "de_SearchUserProfilesCommandError");
5036
+ Object.assign(contents, doc);
5037
+ return contents;
5038
+ }, "de_SearchUserProfilesCommand");
8036
5039
  var de_StartDataSourceRunCommand = /* @__PURE__ */ __name(async (output, context) => {
8037
5040
  if (output.statusCode !== 200 && output.statusCode >= 300) {
8038
- return de_StartDataSourceRunCommandError(output, context);
5041
+ return de_CommandError(output, context);
8039
5042
  }
8040
5043
  const contents = (0, import_smithy_client.map)({
8041
5044
  $metadata: deserializeMetadata(output)
@@ -8059,49 +5062,9 @@ var de_StartDataSourceRunCommand = /* @__PURE__ */ __name(async (output, context
8059
5062
  Object.assign(contents, doc);
8060
5063
  return contents;
8061
5064
  }, "de_StartDataSourceRunCommand");
8062
- var de_StartDataSourceRunCommandError = /* @__PURE__ */ __name(async (output, context) => {
8063
- const parsedOutput = {
8064
- ...output,
8065
- body: await parseErrorBody(output.body, context)
8066
- };
8067
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
8068
- switch (errorCode) {
8069
- case "AccessDeniedException":
8070
- case "com.amazonaws.datazone#AccessDeniedException":
8071
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
8072
- case "ConflictException":
8073
- case "com.amazonaws.datazone#ConflictException":
8074
- throw await de_ConflictExceptionRes(parsedOutput, context);
8075
- case "InternalServerException":
8076
- case "com.amazonaws.datazone#InternalServerException":
8077
- throw await de_InternalServerExceptionRes(parsedOutput, context);
8078
- case "ResourceNotFoundException":
8079
- case "com.amazonaws.datazone#ResourceNotFoundException":
8080
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
8081
- case "ServiceQuotaExceededException":
8082
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
8083
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
8084
- case "ThrottlingException":
8085
- case "com.amazonaws.datazone#ThrottlingException":
8086
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
8087
- case "UnauthorizedException":
8088
- case "com.amazonaws.datazone#UnauthorizedException":
8089
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
8090
- case "ValidationException":
8091
- case "com.amazonaws.datazone#ValidationException":
8092
- throw await de_ValidationExceptionRes(parsedOutput, context);
8093
- default:
8094
- const parsedBody = parsedOutput.body;
8095
- return throwDefaultError({
8096
- output,
8097
- parsedBody,
8098
- errorCode
8099
- });
8100
- }
8101
- }, "de_StartDataSourceRunCommandError");
8102
5065
  var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
8103
5066
  if (output.statusCode !== 200 && output.statusCode >= 300) {
8104
- return de_TagResourceCommandError(output, context);
5067
+ return de_CommandError(output, context);
8105
5068
  }
8106
5069
  const contents = (0, import_smithy_client.map)({
8107
5070
  $metadata: deserializeMetadata(output)
@@ -8109,43 +5072,9 @@ var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
8109
5072
  await (0, import_smithy_client.collectBody)(output.body, context);
8110
5073
  return contents;
8111
5074
  }, "de_TagResourceCommand");
8112
- var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
8113
- const parsedOutput = {
8114
- ...output,
8115
- body: await parseErrorBody(output.body, context)
8116
- };
8117
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
8118
- switch (errorCode) {
8119
- case "AccessDeniedException":
8120
- case "com.amazonaws.datazone#AccessDeniedException":
8121
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
8122
- case "InternalServerException":
8123
- case "com.amazonaws.datazone#InternalServerException":
8124
- throw await de_InternalServerExceptionRes(parsedOutput, context);
8125
- case "ResourceNotFoundException":
8126
- case "com.amazonaws.datazone#ResourceNotFoundException":
8127
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
8128
- case "ThrottlingException":
8129
- case "com.amazonaws.datazone#ThrottlingException":
8130
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
8131
- case "UnauthorizedException":
8132
- case "com.amazonaws.datazone#UnauthorizedException":
8133
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
8134
- case "ValidationException":
8135
- case "com.amazonaws.datazone#ValidationException":
8136
- throw await de_ValidationExceptionRes(parsedOutput, context);
8137
- default:
8138
- const parsedBody = parsedOutput.body;
8139
- return throwDefaultError({
8140
- output,
8141
- parsedBody,
8142
- errorCode
8143
- });
8144
- }
8145
- }, "de_TagResourceCommandError");
8146
5075
  var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
8147
5076
  if (output.statusCode !== 200 && output.statusCode >= 300) {
8148
- return de_UntagResourceCommandError(output, context);
5077
+ return de_CommandError(output, context);
8149
5078
  }
8150
5079
  const contents = (0, import_smithy_client.map)({
8151
5080
  $metadata: deserializeMetadata(output)
@@ -8153,40 +5082,9 @@ var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) =>
8153
5082
  await (0, import_smithy_client.collectBody)(output.body, context);
8154
5083
  return contents;
8155
5084
  }, "de_UntagResourceCommand");
8156
- var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
8157
- const parsedOutput = {
8158
- ...output,
8159
- body: await parseErrorBody(output.body, context)
8160
- };
8161
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
8162
- switch (errorCode) {
8163
- case "AccessDeniedException":
8164
- case "com.amazonaws.datazone#AccessDeniedException":
8165
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
8166
- case "InternalServerException":
8167
- case "com.amazonaws.datazone#InternalServerException":
8168
- throw await de_InternalServerExceptionRes(parsedOutput, context);
8169
- case "ResourceNotFoundException":
8170
- case "com.amazonaws.datazone#ResourceNotFoundException":
8171
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
8172
- case "ThrottlingException":
8173
- case "com.amazonaws.datazone#ThrottlingException":
8174
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
8175
- case "UnauthorizedException":
8176
- case "com.amazonaws.datazone#UnauthorizedException":
8177
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
8178
- default:
8179
- const parsedBody = parsedOutput.body;
8180
- return throwDefaultError({
8181
- output,
8182
- parsedBody,
8183
- errorCode
8184
- });
8185
- }
8186
- }, "de_UntagResourceCommandError");
8187
5085
  var de_UpdateDataSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
8188
5086
  if (output.statusCode !== 200 && output.statusCode >= 300) {
8189
- return de_UpdateDataSourceCommandError(output, context);
5087
+ return de_CommandError(output, context);
8190
5088
  }
8191
5089
  const contents = (0, import_smithy_client.map)({
8192
5090
  $metadata: deserializeMetadata(output)
@@ -8217,49 +5115,9 @@ var de_UpdateDataSourceCommand = /* @__PURE__ */ __name(async (output, context)
8217
5115
  Object.assign(contents, doc);
8218
5116
  return contents;
8219
5117
  }, "de_UpdateDataSourceCommand");
8220
- var de_UpdateDataSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
8221
- const parsedOutput = {
8222
- ...output,
8223
- body: await parseErrorBody(output.body, context)
8224
- };
8225
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
8226
- switch (errorCode) {
8227
- case "AccessDeniedException":
8228
- case "com.amazonaws.datazone#AccessDeniedException":
8229
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
8230
- case "ConflictException":
8231
- case "com.amazonaws.datazone#ConflictException":
8232
- throw await de_ConflictExceptionRes(parsedOutput, context);
8233
- case "InternalServerException":
8234
- case "com.amazonaws.datazone#InternalServerException":
8235
- throw await de_InternalServerExceptionRes(parsedOutput, context);
8236
- case "ResourceNotFoundException":
8237
- case "com.amazonaws.datazone#ResourceNotFoundException":
8238
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
8239
- case "ServiceQuotaExceededException":
8240
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
8241
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
8242
- case "ThrottlingException":
8243
- case "com.amazonaws.datazone#ThrottlingException":
8244
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
8245
- case "UnauthorizedException":
8246
- case "com.amazonaws.datazone#UnauthorizedException":
8247
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
8248
- case "ValidationException":
8249
- case "com.amazonaws.datazone#ValidationException":
8250
- throw await de_ValidationExceptionRes(parsedOutput, context);
8251
- default:
8252
- const parsedBody = parsedOutput.body;
8253
- return throwDefaultError({
8254
- output,
8255
- parsedBody,
8256
- errorCode
8257
- });
8258
- }
8259
- }, "de_UpdateDataSourceCommandError");
8260
5118
  var de_UpdateDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
8261
5119
  if (output.statusCode !== 200 && output.statusCode >= 300) {
8262
- return de_UpdateDomainCommandError(output, context);
5120
+ return de_CommandError(output, context);
8263
5121
  }
8264
5122
  const contents = (0, import_smithy_client.map)({
8265
5123
  $metadata: deserializeMetadata(output)
@@ -8276,49 +5134,9 @@ var de_UpdateDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
8276
5134
  Object.assign(contents, doc);
8277
5135
  return contents;
8278
5136
  }, "de_UpdateDomainCommand");
8279
- var de_UpdateDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
8280
- const parsedOutput = {
8281
- ...output,
8282
- body: await parseErrorBody(output.body, context)
8283
- };
8284
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
8285
- switch (errorCode) {
8286
- case "AccessDeniedException":
8287
- case "com.amazonaws.datazone#AccessDeniedException":
8288
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
8289
- case "ConflictException":
8290
- case "com.amazonaws.datazone#ConflictException":
8291
- throw await de_ConflictExceptionRes(parsedOutput, context);
8292
- case "InternalServerException":
8293
- case "com.amazonaws.datazone#InternalServerException":
8294
- throw await de_InternalServerExceptionRes(parsedOutput, context);
8295
- case "ResourceNotFoundException":
8296
- case "com.amazonaws.datazone#ResourceNotFoundException":
8297
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
8298
- case "ServiceQuotaExceededException":
8299
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
8300
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
8301
- case "ThrottlingException":
8302
- case "com.amazonaws.datazone#ThrottlingException":
8303
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
8304
- case "UnauthorizedException":
8305
- case "com.amazonaws.datazone#UnauthorizedException":
8306
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
8307
- case "ValidationException":
8308
- case "com.amazonaws.datazone#ValidationException":
8309
- throw await de_ValidationExceptionRes(parsedOutput, context);
8310
- default:
8311
- const parsedBody = parsedOutput.body;
8312
- return throwDefaultError({
8313
- output,
8314
- parsedBody,
8315
- errorCode
8316
- });
8317
- }
8318
- }, "de_UpdateDomainCommandError");
8319
5137
  var de_UpdateEnvironmentCommand = /* @__PURE__ */ __name(async (output, context) => {
8320
5138
  if (output.statusCode !== 200 && output.statusCode >= 300) {
8321
- return de_UpdateEnvironmentCommandError(output, context);
5139
+ return de_CommandError(output, context);
8322
5140
  }
8323
5141
  const contents = (0, import_smithy_client.map)({
8324
5142
  $metadata: deserializeMetadata(output)
@@ -8350,46 +5168,9 @@ var de_UpdateEnvironmentCommand = /* @__PURE__ */ __name(async (output, context)
8350
5168
  Object.assign(contents, doc);
8351
5169
  return contents;
8352
5170
  }, "de_UpdateEnvironmentCommand");
8353
- var de_UpdateEnvironmentCommandError = /* @__PURE__ */ __name(async (output, context) => {
8354
- const parsedOutput = {
8355
- ...output,
8356
- body: await parseErrorBody(output.body, context)
8357
- };
8358
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
8359
- switch (errorCode) {
8360
- case "AccessDeniedException":
8361
- case "com.amazonaws.datazone#AccessDeniedException":
8362
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
8363
- case "ConflictException":
8364
- case "com.amazonaws.datazone#ConflictException":
8365
- throw await de_ConflictExceptionRes(parsedOutput, context);
8366
- case "InternalServerException":
8367
- case "com.amazonaws.datazone#InternalServerException":
8368
- throw await de_InternalServerExceptionRes(parsedOutput, context);
8369
- case "ServiceQuotaExceededException":
8370
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
8371
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
8372
- case "ThrottlingException":
8373
- case "com.amazonaws.datazone#ThrottlingException":
8374
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
8375
- case "UnauthorizedException":
8376
- case "com.amazonaws.datazone#UnauthorizedException":
8377
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
8378
- case "ValidationException":
8379
- case "com.amazonaws.datazone#ValidationException":
8380
- throw await de_ValidationExceptionRes(parsedOutput, context);
8381
- default:
8382
- const parsedBody = parsedOutput.body;
8383
- return throwDefaultError({
8384
- output,
8385
- parsedBody,
8386
- errorCode
8387
- });
8388
- }
8389
- }, "de_UpdateEnvironmentCommandError");
8390
5171
  var de_UpdateEnvironmentProfileCommand = /* @__PURE__ */ __name(async (output, context) => {
8391
5172
  if (output.statusCode !== 200 && output.statusCode >= 300) {
8392
- return de_UpdateEnvironmentProfileCommandError(output, context);
5173
+ return de_CommandError(output, context);
8393
5174
  }
8394
5175
  const contents = (0, import_smithy_client.map)({
8395
5176
  $metadata: deserializeMetadata(output)
@@ -8407,54 +5188,14 @@ var de_UpdateEnvironmentProfileCommand = /* @__PURE__ */ __name(async (output, c
8407
5188
  name: import_smithy_client.expectString,
8408
5189
  projectId: import_smithy_client.expectString,
8409
5190
  updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
8410
- userParameters: import_smithy_client._json
8411
- });
8412
- Object.assign(contents, doc);
8413
- return contents;
8414
- }, "de_UpdateEnvironmentProfileCommand");
8415
- var de_UpdateEnvironmentProfileCommandError = /* @__PURE__ */ __name(async (output, context) => {
8416
- const parsedOutput = {
8417
- ...output,
8418
- body: await parseErrorBody(output.body, context)
8419
- };
8420
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
8421
- switch (errorCode) {
8422
- case "AccessDeniedException":
8423
- case "com.amazonaws.datazone#AccessDeniedException":
8424
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
8425
- case "ConflictException":
8426
- case "com.amazonaws.datazone#ConflictException":
8427
- throw await de_ConflictExceptionRes(parsedOutput, context);
8428
- case "InternalServerException":
8429
- case "com.amazonaws.datazone#InternalServerException":
8430
- throw await de_InternalServerExceptionRes(parsedOutput, context);
8431
- case "ResourceNotFoundException":
8432
- case "com.amazonaws.datazone#ResourceNotFoundException":
8433
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
8434
- case "ServiceQuotaExceededException":
8435
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
8436
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
8437
- case "ThrottlingException":
8438
- case "com.amazonaws.datazone#ThrottlingException":
8439
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
8440
- case "UnauthorizedException":
8441
- case "com.amazonaws.datazone#UnauthorizedException":
8442
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
8443
- case "ValidationException":
8444
- case "com.amazonaws.datazone#ValidationException":
8445
- throw await de_ValidationExceptionRes(parsedOutput, context);
8446
- default:
8447
- const parsedBody = parsedOutput.body;
8448
- return throwDefaultError({
8449
- output,
8450
- parsedBody,
8451
- errorCode
8452
- });
8453
- }
8454
- }, "de_UpdateEnvironmentProfileCommandError");
5191
+ userParameters: import_smithy_client._json
5192
+ });
5193
+ Object.assign(contents, doc);
5194
+ return contents;
5195
+ }, "de_UpdateEnvironmentProfileCommand");
8455
5196
  var de_UpdateGlossaryCommand = /* @__PURE__ */ __name(async (output, context) => {
8456
5197
  if (output.statusCode !== 200 && output.statusCode >= 300) {
8457
- return de_UpdateGlossaryCommandError(output, context);
5198
+ return de_CommandError(output, context);
8458
5199
  }
8459
5200
  const contents = (0, import_smithy_client.map)({
8460
5201
  $metadata: deserializeMetadata(output)
@@ -8471,46 +5212,9 @@ var de_UpdateGlossaryCommand = /* @__PURE__ */ __name(async (output, context) =>
8471
5212
  Object.assign(contents, doc);
8472
5213
  return contents;
8473
5214
  }, "de_UpdateGlossaryCommand");
8474
- var de_UpdateGlossaryCommandError = /* @__PURE__ */ __name(async (output, context) => {
8475
- const parsedOutput = {
8476
- ...output,
8477
- body: await parseErrorBody(output.body, context)
8478
- };
8479
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
8480
- switch (errorCode) {
8481
- case "AccessDeniedException":
8482
- case "com.amazonaws.datazone#AccessDeniedException":
8483
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
8484
- case "ConflictException":
8485
- case "com.amazonaws.datazone#ConflictException":
8486
- throw await de_ConflictExceptionRes(parsedOutput, context);
8487
- case "InternalServerException":
8488
- case "com.amazonaws.datazone#InternalServerException":
8489
- throw await de_InternalServerExceptionRes(parsedOutput, context);
8490
- case "ResourceNotFoundException":
8491
- case "com.amazonaws.datazone#ResourceNotFoundException":
8492
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
8493
- case "ThrottlingException":
8494
- case "com.amazonaws.datazone#ThrottlingException":
8495
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
8496
- case "UnauthorizedException":
8497
- case "com.amazonaws.datazone#UnauthorizedException":
8498
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
8499
- case "ValidationException":
8500
- case "com.amazonaws.datazone#ValidationException":
8501
- throw await de_ValidationExceptionRes(parsedOutput, context);
8502
- default:
8503
- const parsedBody = parsedOutput.body;
8504
- return throwDefaultError({
8505
- output,
8506
- parsedBody,
8507
- errorCode
8508
- });
8509
- }
8510
- }, "de_UpdateGlossaryCommandError");
8511
5215
  var de_UpdateGlossaryTermCommand = /* @__PURE__ */ __name(async (output, context) => {
8512
5216
  if (output.statusCode !== 200 && output.statusCode >= 300) {
8513
- return de_UpdateGlossaryTermCommandError(output, context);
5217
+ return de_CommandError(output, context);
8514
5218
  }
8515
5219
  const contents = (0, import_smithy_client.map)({
8516
5220
  $metadata: deserializeMetadata(output)
@@ -8529,46 +5233,9 @@ var de_UpdateGlossaryTermCommand = /* @__PURE__ */ __name(async (output, context
8529
5233
  Object.assign(contents, doc);
8530
5234
  return contents;
8531
5235
  }, "de_UpdateGlossaryTermCommand");
8532
- var de_UpdateGlossaryTermCommandError = /* @__PURE__ */ __name(async (output, context) => {
8533
- const parsedOutput = {
8534
- ...output,
8535
- body: await parseErrorBody(output.body, context)
8536
- };
8537
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
8538
- switch (errorCode) {
8539
- case "AccessDeniedException":
8540
- case "com.amazonaws.datazone#AccessDeniedException":
8541
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
8542
- case "ConflictException":
8543
- case "com.amazonaws.datazone#ConflictException":
8544
- throw await de_ConflictExceptionRes(parsedOutput, context);
8545
- case "InternalServerException":
8546
- case "com.amazonaws.datazone#InternalServerException":
8547
- throw await de_InternalServerExceptionRes(parsedOutput, context);
8548
- case "ResourceNotFoundException":
8549
- case "com.amazonaws.datazone#ResourceNotFoundException":
8550
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
8551
- case "ThrottlingException":
8552
- case "com.amazonaws.datazone#ThrottlingException":
8553
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
8554
- case "UnauthorizedException":
8555
- case "com.amazonaws.datazone#UnauthorizedException":
8556
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
8557
- case "ValidationException":
8558
- case "com.amazonaws.datazone#ValidationException":
8559
- throw await de_ValidationExceptionRes(parsedOutput, context);
8560
- default:
8561
- const parsedBody = parsedOutput.body;
8562
- return throwDefaultError({
8563
- output,
8564
- parsedBody,
8565
- errorCode
8566
- });
8567
- }
8568
- }, "de_UpdateGlossaryTermCommandError");
8569
5236
  var de_UpdateGroupProfileCommand = /* @__PURE__ */ __name(async (output, context) => {
8570
5237
  if (output.statusCode !== 200 && output.statusCode >= 300) {
8571
- return de_UpdateGroupProfileCommandError(output, context);
5238
+ return de_CommandError(output, context);
8572
5239
  }
8573
5240
  const contents = (0, import_smithy_client.map)({
8574
5241
  $metadata: deserializeMetadata(output)
@@ -8583,43 +5250,9 @@ var de_UpdateGroupProfileCommand = /* @__PURE__ */ __name(async (output, context
8583
5250
  Object.assign(contents, doc);
8584
5251
  return contents;
8585
5252
  }, "de_UpdateGroupProfileCommand");
8586
- var de_UpdateGroupProfileCommandError = /* @__PURE__ */ __name(async (output, context) => {
8587
- const parsedOutput = {
8588
- ...output,
8589
- body: await parseErrorBody(output.body, context)
8590
- };
8591
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
8592
- switch (errorCode) {
8593
- case "AccessDeniedException":
8594
- case "com.amazonaws.datazone#AccessDeniedException":
8595
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
8596
- case "InternalServerException":
8597
- case "com.amazonaws.datazone#InternalServerException":
8598
- throw await de_InternalServerExceptionRes(parsedOutput, context);
8599
- case "ResourceNotFoundException":
8600
- case "com.amazonaws.datazone#ResourceNotFoundException":
8601
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
8602
- case "ThrottlingException":
8603
- case "com.amazonaws.datazone#ThrottlingException":
8604
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
8605
- case "UnauthorizedException":
8606
- case "com.amazonaws.datazone#UnauthorizedException":
8607
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
8608
- case "ValidationException":
8609
- case "com.amazonaws.datazone#ValidationException":
8610
- throw await de_ValidationExceptionRes(parsedOutput, context);
8611
- default:
8612
- const parsedBody = parsedOutput.body;
8613
- return throwDefaultError({
8614
- output,
8615
- parsedBody,
8616
- errorCode
8617
- });
8618
- }
8619
- }, "de_UpdateGroupProfileCommandError");
8620
5253
  var de_UpdateProjectCommand = /* @__PURE__ */ __name(async (output, context) => {
8621
5254
  if (output.statusCode !== 200 && output.statusCode >= 300) {
8622
- return de_UpdateProjectCommandError(output, context);
5255
+ return de_CommandError(output, context);
8623
5256
  }
8624
5257
  const contents = (0, import_smithy_client.map)({
8625
5258
  $metadata: deserializeMetadata(output)
@@ -8640,49 +5273,9 @@ var de_UpdateProjectCommand = /* @__PURE__ */ __name(async (output, context) =>
8640
5273
  Object.assign(contents, doc);
8641
5274
  return contents;
8642
5275
  }, "de_UpdateProjectCommand");
8643
- var de_UpdateProjectCommandError = /* @__PURE__ */ __name(async (output, context) => {
8644
- const parsedOutput = {
8645
- ...output,
8646
- body: await parseErrorBody(output.body, context)
8647
- };
8648
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
8649
- switch (errorCode) {
8650
- case "AccessDeniedException":
8651
- case "com.amazonaws.datazone#AccessDeniedException":
8652
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
8653
- case "ConflictException":
8654
- case "com.amazonaws.datazone#ConflictException":
8655
- throw await de_ConflictExceptionRes(parsedOutput, context);
8656
- case "InternalServerException":
8657
- case "com.amazonaws.datazone#InternalServerException":
8658
- throw await de_InternalServerExceptionRes(parsedOutput, context);
8659
- case "ResourceNotFoundException":
8660
- case "com.amazonaws.datazone#ResourceNotFoundException":
8661
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
8662
- case "ServiceQuotaExceededException":
8663
- case "com.amazonaws.datazone#ServiceQuotaExceededException":
8664
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
8665
- case "ThrottlingException":
8666
- case "com.amazonaws.datazone#ThrottlingException":
8667
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
8668
- case "UnauthorizedException":
8669
- case "com.amazonaws.datazone#UnauthorizedException":
8670
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
8671
- case "ValidationException":
8672
- case "com.amazonaws.datazone#ValidationException":
8673
- throw await de_ValidationExceptionRes(parsedOutput, context);
8674
- default:
8675
- const parsedBody = parsedOutput.body;
8676
- return throwDefaultError({
8677
- output,
8678
- parsedBody,
8679
- errorCode
8680
- });
8681
- }
8682
- }, "de_UpdateProjectCommandError");
8683
5276
  var de_UpdateSubscriptionGrantStatusCommand = /* @__PURE__ */ __name(async (output, context) => {
8684
5277
  if (output.statusCode !== 200 && output.statusCode >= 300) {
8685
- return de_UpdateSubscriptionGrantStatusCommandError(output, context);
5278
+ return de_CommandError(output, context);
8686
5279
  }
8687
5280
  const contents = (0, import_smithy_client.map)({
8688
5281
  $metadata: deserializeMetadata(output)
@@ -8704,46 +5297,9 @@ var de_UpdateSubscriptionGrantStatusCommand = /* @__PURE__ */ __name(async (outp
8704
5297
  Object.assign(contents, doc);
8705
5298
  return contents;
8706
5299
  }, "de_UpdateSubscriptionGrantStatusCommand");
8707
- var de_UpdateSubscriptionGrantStatusCommandError = /* @__PURE__ */ __name(async (output, context) => {
8708
- const parsedOutput = {
8709
- ...output,
8710
- body: await parseErrorBody(output.body, context)
8711
- };
8712
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
8713
- switch (errorCode) {
8714
- case "AccessDeniedException":
8715
- case "com.amazonaws.datazone#AccessDeniedException":
8716
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
8717
- case "ConflictException":
8718
- case "com.amazonaws.datazone#ConflictException":
8719
- throw await de_ConflictExceptionRes(parsedOutput, context);
8720
- case "InternalServerException":
8721
- case "com.amazonaws.datazone#InternalServerException":
8722
- throw await de_InternalServerExceptionRes(parsedOutput, context);
8723
- case "ResourceNotFoundException":
8724
- case "com.amazonaws.datazone#ResourceNotFoundException":
8725
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
8726
- case "ThrottlingException":
8727
- case "com.amazonaws.datazone#ThrottlingException":
8728
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
8729
- case "UnauthorizedException":
8730
- case "com.amazonaws.datazone#UnauthorizedException":
8731
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
8732
- case "ValidationException":
8733
- case "com.amazonaws.datazone#ValidationException":
8734
- throw await de_ValidationExceptionRes(parsedOutput, context);
8735
- default:
8736
- const parsedBody = parsedOutput.body;
8737
- return throwDefaultError({
8738
- output,
8739
- parsedBody,
8740
- errorCode
8741
- });
8742
- }
8743
- }, "de_UpdateSubscriptionGrantStatusCommandError");
8744
5300
  var de_UpdateSubscriptionRequestCommand = /* @__PURE__ */ __name(async (output, context) => {
8745
5301
  if (output.statusCode !== 200 && output.statusCode >= 300) {
8746
- return de_UpdateSubscriptionRequestCommandError(output, context);
5302
+ return de_CommandError(output, context);
8747
5303
  }
8748
5304
  const contents = (0, import_smithy_client.map)({
8749
5305
  $metadata: deserializeMetadata(output)
@@ -8766,46 +5322,9 @@ var de_UpdateSubscriptionRequestCommand = /* @__PURE__ */ __name(async (output,
8766
5322
  Object.assign(contents, doc);
8767
5323
  return contents;
8768
5324
  }, "de_UpdateSubscriptionRequestCommand");
8769
- var de_UpdateSubscriptionRequestCommandError = /* @__PURE__ */ __name(async (output, context) => {
8770
- const parsedOutput = {
8771
- ...output,
8772
- body: await parseErrorBody(output.body, context)
8773
- };
8774
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
8775
- switch (errorCode) {
8776
- case "AccessDeniedException":
8777
- case "com.amazonaws.datazone#AccessDeniedException":
8778
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
8779
- case "ConflictException":
8780
- case "com.amazonaws.datazone#ConflictException":
8781
- throw await de_ConflictExceptionRes(parsedOutput, context);
8782
- case "InternalServerException":
8783
- case "com.amazonaws.datazone#InternalServerException":
8784
- throw await de_InternalServerExceptionRes(parsedOutput, context);
8785
- case "ResourceNotFoundException":
8786
- case "com.amazonaws.datazone#ResourceNotFoundException":
8787
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
8788
- case "ThrottlingException":
8789
- case "com.amazonaws.datazone#ThrottlingException":
8790
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
8791
- case "UnauthorizedException":
8792
- case "com.amazonaws.datazone#UnauthorizedException":
8793
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
8794
- case "ValidationException":
8795
- case "com.amazonaws.datazone#ValidationException":
8796
- throw await de_ValidationExceptionRes(parsedOutput, context);
8797
- default:
8798
- const parsedBody = parsedOutput.body;
8799
- return throwDefaultError({
8800
- output,
8801
- parsedBody,
8802
- errorCode
8803
- });
8804
- }
8805
- }, "de_UpdateSubscriptionRequestCommandError");
8806
5325
  var de_UpdateSubscriptionTargetCommand = /* @__PURE__ */ __name(async (output, context) => {
8807
5326
  if (output.statusCode !== 200 && output.statusCode >= 300) {
8808
- return de_UpdateSubscriptionTargetCommandError(output, context);
5327
+ return de_CommandError(output, context);
8809
5328
  }
8810
5329
  const contents = (0, import_smithy_client.map)({
8811
5330
  $metadata: deserializeMetadata(output)
@@ -8831,46 +5350,9 @@ var de_UpdateSubscriptionTargetCommand = /* @__PURE__ */ __name(async (output, c
8831
5350
  Object.assign(contents, doc);
8832
5351
  return contents;
8833
5352
  }, "de_UpdateSubscriptionTargetCommand");
8834
- var de_UpdateSubscriptionTargetCommandError = /* @__PURE__ */ __name(async (output, context) => {
8835
- const parsedOutput = {
8836
- ...output,
8837
- body: await parseErrorBody(output.body, context)
8838
- };
8839
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
8840
- switch (errorCode) {
8841
- case "AccessDeniedException":
8842
- case "com.amazonaws.datazone#AccessDeniedException":
8843
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
8844
- case "ConflictException":
8845
- case "com.amazonaws.datazone#ConflictException":
8846
- throw await de_ConflictExceptionRes(parsedOutput, context);
8847
- case "InternalServerException":
8848
- case "com.amazonaws.datazone#InternalServerException":
8849
- throw await de_InternalServerExceptionRes(parsedOutput, context);
8850
- case "ResourceNotFoundException":
8851
- case "com.amazonaws.datazone#ResourceNotFoundException":
8852
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
8853
- case "ThrottlingException":
8854
- case "com.amazonaws.datazone#ThrottlingException":
8855
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
8856
- case "UnauthorizedException":
8857
- case "com.amazonaws.datazone#UnauthorizedException":
8858
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
8859
- case "ValidationException":
8860
- case "com.amazonaws.datazone#ValidationException":
8861
- throw await de_ValidationExceptionRes(parsedOutput, context);
8862
- default:
8863
- const parsedBody = parsedOutput.body;
8864
- return throwDefaultError({
8865
- output,
8866
- parsedBody,
8867
- errorCode
8868
- });
8869
- }
8870
- }, "de_UpdateSubscriptionTargetCommandError");
8871
5353
  var de_UpdateUserProfileCommand = /* @__PURE__ */ __name(async (output, context) => {
8872
5354
  if (output.statusCode !== 200 && output.statusCode >= 300) {
8873
- return de_UpdateUserProfileCommandError(output, context);
5355
+ return de_CommandError(output, context);
8874
5356
  }
8875
5357
  const contents = (0, import_smithy_client.map)({
8876
5358
  $metadata: deserializeMetadata(output)
@@ -8886,7 +5368,7 @@ var de_UpdateUserProfileCommand = /* @__PURE__ */ __name(async (output, context)
8886
5368
  Object.assign(contents, doc);
8887
5369
  return contents;
8888
5370
  }, "de_UpdateUserProfileCommand");
8889
- var de_UpdateUserProfileCommandError = /* @__PURE__ */ __name(async (output, context) => {
5371
+ var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
8890
5372
  const parsedOutput = {
8891
5373
  ...output,
8892
5374
  body: await parseErrorBody(output.body, context)
@@ -8896,6 +5378,9 @@ var de_UpdateUserProfileCommandError = /* @__PURE__ */ __name(async (output, con
8896
5378
  case "AccessDeniedException":
8897
5379
  case "com.amazonaws.datazone#AccessDeniedException":
8898
5380
  throw await de_AccessDeniedExceptionRes(parsedOutput, context);
5381
+ case "ConflictException":
5382
+ case "com.amazonaws.datazone#ConflictException":
5383
+ throw await de_ConflictExceptionRes(parsedOutput, context);
8899
5384
  case "InternalServerException":
8900
5385
  case "com.amazonaws.datazone#InternalServerException":
8901
5386
  throw await de_InternalServerExceptionRes(parsedOutput, context);
@@ -8911,6 +5396,9 @@ var de_UpdateUserProfileCommandError = /* @__PURE__ */ __name(async (output, con
8911
5396
  case "ValidationException":
8912
5397
  case "com.amazonaws.datazone#ValidationException":
8913
5398
  throw await de_ValidationExceptionRes(parsedOutput, context);
5399
+ case "ServiceQuotaExceededException":
5400
+ case "com.amazonaws.datazone#ServiceQuotaExceededException":
5401
+ throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
8914
5402
  default:
8915
5403
  const parsedBody = parsedOutput.body;
8916
5404
  return throwDefaultError({
@@ -8919,7 +5407,7 @@ var de_UpdateUserProfileCommandError = /* @__PURE__ */ __name(async (output, con
8919
5407
  errorCode
8920
5408
  });
8921
5409
  }
8922
- }, "de_UpdateUserProfileCommandError");
5410
+ }, "de_CommandError");
8923
5411
  var throwDefaultError = (0, import_smithy_client.withBaseException)(DataZoneServiceException);
8924
5412
  var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
8925
5413
  const contents = (0, import_smithy_client.map)({});