@aws-sdk/client-cloudwatch 3.503.1 → 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.
Files changed (3) hide show
  1. package/dist-cjs/index.js +76 -921
  2. package/dist-es/protocols/Aws_query.js +99 -944
  3. package/package.json +3 -3
package/dist-es/protocols/Aws_query.js CHANGED
@@ -2,7 +2,7 @@ import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
2
  import { collectBody, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectString as __expectString, extendedEncodeURIComponent as __extendedEncodeURIComponent, getArrayIfSingleItem as __getArrayIfSingleItem, getValueFromTextNode as __getValueFromTextNode, parseBoolean as __parseBoolean, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, serializeFloat as __serializeFloat, strictParseFloat as __strictParseFloat, strictParseInt32 as __strictParseInt32, strictParseLong as __strictParseLong, withBaseException, } from "@smithy/smithy-client";
3
3
  import { XMLParser } from "fast-xml-parser";
4
4
  import { CloudWatchServiceException as __BaseException } from "../models/CloudWatchServiceException";
5
- import { ConcurrentModificationException, DashboardInvalidInputError, DashboardNotFoundError, InternalServiceFault, InvalidFormatFault, InvalidNextToken, InvalidParameterCombinationException, InvalidParameterValueException, LimitExceededException, LimitExceededFault, MissingRequiredParameterException, ResourceNotFound, ResourceNotFoundException, } from "../models/models_0";
5
+ import { ConcurrentModificationException, DashboardInvalidInputError, InternalServiceFault, InvalidFormatFault, InvalidNextToken, InvalidParameterCombinationException, InvalidParameterValueException, LimitExceededException, LimitExceededFault, MissingRequiredParameterException, ResourceNotFound, ResourceNotFoundException, } from "../models/models_0";
6
6
  export const se_DeleteAlarmsCommand = async (input, context) => {
7
7
  const headers = SHARED_HEADERS;
8
8
  let body;
@@ -385,7 +385,7 @@ export const se_UntagResourceCommand = async (input, context) => {
385
385
  };
386
386
  export const de_DeleteAlarmsCommand = async (output, context) => {
387
387
  if (output.statusCode >= 300) {
388
- return de_DeleteAlarmsCommandError(output, context);
388
+ return de_CommandError(output, context);
389
389
  }
390
390
  await collectBody(output.body, context);
391
391
  const response = {
@@ -393,28 +393,9 @@ export const de_DeleteAlarmsCommand = async (output, context) => {
393
393
  };
394
394
  return response;
395
395
  };
396
- const de_DeleteAlarmsCommandError = async (output, context) => {
397
- const parsedOutput = {
398
- ...output,
399
- body: await parseErrorBody(output.body, context),
400
- };
401
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
402
- switch (errorCode) {
403
- case "ResourceNotFound":
404
- case "com.amazonaws.cloudwatch#ResourceNotFound":
405
- throw await de_ResourceNotFoundRes(parsedOutput, context);
406
- default:
407
- const parsedBody = parsedOutput.body;
408
- return throwDefaultError({
409
- output,
410
- parsedBody: parsedBody.Error,
411
- errorCode,
412
- });
413
- }
414
- };
415
396
  export const de_DeleteAnomalyDetectorCommand = async (output, context) => {
416
397
  if (output.statusCode >= 300) {
417
- return de_DeleteAnomalyDetectorCommandError(output, context);
398
+ return de_CommandError(output, context);
418
399
  }
419
400
  const data = await parseBody(output.body, context);
420
401
  let contents = {};
@@ -425,40 +406,9 @@ export const de_DeleteAnomalyDetectorCommand = async (output, context) => {
425
406
  };
426
407
  return response;
427
408
  };
428
- const de_DeleteAnomalyDetectorCommandError = async (output, context) => {
429
- const parsedOutput = {
430
- ...output,
431
- body: await parseErrorBody(output.body, context),
432
- };
433
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
434
- switch (errorCode) {
435
- case "InternalServiceError":
436
- case "com.amazonaws.cloudwatch#InternalServiceFault":
437
- throw await de_InternalServiceFaultRes(parsedOutput, context);
438
- case "InvalidParameterCombination":
439
- case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
440
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
441
- case "InvalidParameterValue":
442
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
443
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
444
- case "MissingParameter":
445
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
446
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
447
- case "ResourceNotFoundException":
448
- case "com.amazonaws.cloudwatch#ResourceNotFoundException":
449
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
450
- default:
451
- const parsedBody = parsedOutput.body;
452
- return throwDefaultError({
453
- output,
454
- parsedBody: parsedBody.Error,
455
- errorCode,
456
- });
457
- }
458
- };
459
409
  export const de_DeleteDashboardsCommand = async (output, context) => {
460
410
  if (output.statusCode >= 300) {
461
- return de_DeleteDashboardsCommandError(output, context);
411
+ return de_CommandError(output, context);
462
412
  }
463
413
  const data = await parseBody(output.body, context);
464
414
  let contents = {};
@@ -469,34 +419,9 @@ export const de_DeleteDashboardsCommand = async (output, context) => {
469
419
  };
470
420
  return response;
471
421
  };
472
- const de_DeleteDashboardsCommandError = async (output, context) => {
473
- const parsedOutput = {
474
- ...output,
475
- body: await parseErrorBody(output.body, context),
476
- };
477
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
478
- switch (errorCode) {
479
- case "InternalServiceError":
480
- case "com.amazonaws.cloudwatch#InternalServiceFault":
481
- throw await de_InternalServiceFaultRes(parsedOutput, context);
482
- case "InvalidParameterValue":
483
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
484
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
485
- case "ResourceNotFound":
486
- case "com.amazonaws.cloudwatch#DashboardNotFoundError":
487
- throw await de_DashboardNotFoundErrorRes(parsedOutput, context);
488
- default:
489
- const parsedBody = parsedOutput.body;
490
- return throwDefaultError({
491
- output,
492
- parsedBody: parsedBody.Error,
493
- errorCode,
494
- });
495
- }
496
- };
497
422
  export const de_DeleteInsightRulesCommand = async (output, context) => {
498
423
  if (output.statusCode >= 300) {
499
- return de_DeleteInsightRulesCommandError(output, context);
424
+ return de_CommandError(output, context);
500
425
  }
501
426
  const data = await parseBody(output.body, context);
502
427
  let contents = {};
@@ -507,31 +432,9 @@ export const de_DeleteInsightRulesCommand = async (output, context) => {
507
432
  };
508
433
  return response;
509
434
  };
510
- const de_DeleteInsightRulesCommandError = async (output, context) => {
511
- const parsedOutput = {
512
- ...output,
513
- body: await parseErrorBody(output.body, context),
514
- };
515
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
516
- switch (errorCode) {
517
- case "InvalidParameterValue":
518
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
519
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
520
- case "MissingParameter":
521
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
522
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
523
- default:
524
- const parsedBody = parsedOutput.body;
525
- return throwDefaultError({
526
- output,
527
- parsedBody: parsedBody.Error,
528
- errorCode,
529
- });
530
- }
531
- };
532
435
  export const de_DeleteMetricStreamCommand = async (output, context) => {
533
436
  if (output.statusCode >= 300) {
534
- return de_DeleteMetricStreamCommandError(output, context);
437
+ return de_CommandError(output, context);
535
438
  }
536
439
  const data = await parseBody(output.body, context);
537
440
  let contents = {};
@@ -542,34 +445,9 @@ export const de_DeleteMetricStreamCommand = async (output, context) => {
542
445
  };
543
446
  return response;
544
447
  };
545
- const de_DeleteMetricStreamCommandError = async (output, context) => {
546
- const parsedOutput = {
547
- ...output,
548
- body: await parseErrorBody(output.body, context),
549
- };
550
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
551
- switch (errorCode) {
552
- case "InternalServiceError":
553
- case "com.amazonaws.cloudwatch#InternalServiceFault":
554
- throw await de_InternalServiceFaultRes(parsedOutput, context);
555
- case "InvalidParameterValue":
556
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
557
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
558
- case "MissingParameter":
559
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
560
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
561
- default:
562
- const parsedBody = parsedOutput.body;
563
- return throwDefaultError({
564
- output,
565
- parsedBody: parsedBody.Error,
566
- errorCode,
567
- });
568
- }
569
- };
570
448
  export const de_DescribeAlarmHistoryCommand = async (output, context) => {
571
449
  if (output.statusCode >= 300) {
572
- return de_DescribeAlarmHistoryCommandError(output, context);
450
+ return de_CommandError(output, context);
573
451
  }
574
452
  const data = await parseBody(output.body, context);
575
453
  let contents = {};
@@ -580,28 +458,9 @@ export const de_DescribeAlarmHistoryCommand = async (output, context) => {
580
458
  };
581
459
  return response;
582
460
  };
583
- const de_DescribeAlarmHistoryCommandError = async (output, context) => {
584
- const parsedOutput = {
585
- ...output,
586
- body: await parseErrorBody(output.body, context),
587
- };
588
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
589
- switch (errorCode) {
590
- case "InvalidNextToken":
591
- case "com.amazonaws.cloudwatch#InvalidNextToken":
592
- throw await de_InvalidNextTokenRes(parsedOutput, context);
593
- default:
594
- const parsedBody = parsedOutput.body;
595
- return throwDefaultError({
596
- output,
597
- parsedBody: parsedBody.Error,
598
- errorCode,
599
- });
600
- }
601
- };
602
461
  export const de_DescribeAlarmsCommand = async (output, context) => {
603
462
  if (output.statusCode >= 300) {
604
- return de_DescribeAlarmsCommandError(output, context);
463
+ return de_CommandError(output, context);
605
464
  }
606
465
  const data = await parseBody(output.body, context);
607
466
  let contents = {};
@@ -612,28 +471,9 @@ export const de_DescribeAlarmsCommand = async (output, context) => {
612
471
  };
613
472
  return response;
614
473
  };
615
- const de_DescribeAlarmsCommandError = async (output, context) => {
616
- const parsedOutput = {
617
- ...output,
618
- body: await parseErrorBody(output.body, context),
619
- };
620
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
621
- switch (errorCode) {
622
- case "InvalidNextToken":
623
- case "com.amazonaws.cloudwatch#InvalidNextToken":
624
- throw await de_InvalidNextTokenRes(parsedOutput, context);
625
- default:
626
- const parsedBody = parsedOutput.body;
627
- return throwDefaultError({
628
- output,
629
- parsedBody: parsedBody.Error,
630
- errorCode,
631
- });
632
- }
633
- };
634
474
  export const de_DescribeAlarmsForMetricCommand = async (output, context) => {
635
475
  if (output.statusCode >= 300) {
636
- return de_DescribeAlarmsForMetricCommandError(output, context);
476
+ return de_CommandError(output, context);
637
477
  }
638
478
  const data = await parseBody(output.body, context);
639
479
  let contents = {};
@@ -644,22 +484,9 @@ export const de_DescribeAlarmsForMetricCommand = async (output, context) => {
644
484
  };
645
485
  return response;
646
486
  };
647
- const de_DescribeAlarmsForMetricCommandError = async (output, context) => {
648
- const parsedOutput = {
649
- ...output,
650
- body: await parseErrorBody(output.body, context),
651
- };
652
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
653
- const parsedBody = parsedOutput.body;
654
- return throwDefaultError({
655
- output,
656
- parsedBody: parsedBody.Error,
657
- errorCode,
658
- });
659
- };
660
487
  export const de_DescribeAnomalyDetectorsCommand = async (output, context) => {
661
488
  if (output.statusCode >= 300) {
662
- return de_DescribeAnomalyDetectorsCommandError(output, context);
489
+ return de_CommandError(output, context);
663
490
  }
664
491
  const data = await parseBody(output.body, context);
665
492
  let contents = {};
@@ -670,37 +497,9 @@ export const de_DescribeAnomalyDetectorsCommand = async (output, context) => {
670
497
  };
671
498
  return response;
672
499
  };
673
- const de_DescribeAnomalyDetectorsCommandError = async (output, context) => {
674
- const parsedOutput = {
675
- ...output,
676
- body: await parseErrorBody(output.body, context),
677
- };
678
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
679
- switch (errorCode) {
680
- case "InternalServiceError":
681
- case "com.amazonaws.cloudwatch#InternalServiceFault":
682
- throw await de_InternalServiceFaultRes(parsedOutput, context);
683
- case "InvalidNextToken":
684
- case "com.amazonaws.cloudwatch#InvalidNextToken":
685
- throw await de_InvalidNextTokenRes(parsedOutput, context);
686
- case "InvalidParameterCombination":
687
- case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
688
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
689
- case "InvalidParameterValue":
690
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
691
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
692
- default:
693
- const parsedBody = parsedOutput.body;
694
- return throwDefaultError({
695
- output,
696
- parsedBody: parsedBody.Error,
697
- errorCode,
698
- });
699
- }
700
- };
701
500
  export const de_DescribeInsightRulesCommand = async (output, context) => {
702
501
  if (output.statusCode >= 300) {
703
- return de_DescribeInsightRulesCommandError(output, context);
502
+ return de_CommandError(output, context);
704
503
  }
705
504
  const data = await parseBody(output.body, context);
706
505
  let contents = {};
@@ -711,28 +510,9 @@ export const de_DescribeInsightRulesCommand = async (output, context) => {
711
510
  };
712
511
  return response;
713
512
  };
714
- const de_DescribeInsightRulesCommandError = async (output, context) => {
715
- const parsedOutput = {
716
- ...output,
717
- body: await parseErrorBody(output.body, context),
718
- };
719
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
720
- switch (errorCode) {
721
- case "InvalidNextToken":
722
- case "com.amazonaws.cloudwatch#InvalidNextToken":
723
- throw await de_InvalidNextTokenRes(parsedOutput, context);
724
- default:
725
- const parsedBody = parsedOutput.body;
726
- return throwDefaultError({
727
- output,
728
- parsedBody: parsedBody.Error,
729
- errorCode,
730
- });
731
- }
732
- };
733
513
  export const de_DisableAlarmActionsCommand = async (output, context) => {
734
514
  if (output.statusCode >= 300) {
735
- return de_DisableAlarmActionsCommandError(output, context);
515
+ return de_CommandError(output, context);
736
516
  }
737
517
  await collectBody(output.body, context);
738
518
  const response = {
@@ -740,22 +520,9 @@ export const de_DisableAlarmActionsCommand = async (output, context) => {
740
520
  };
741
521
  return response;
742
522
  };
743
- const de_DisableAlarmActionsCommandError = async (output, context) => {
744
- const parsedOutput = {
745
- ...output,
746
- body: await parseErrorBody(output.body, context),
747
- };
748
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
749
- const parsedBody = parsedOutput.body;
750
- return throwDefaultError({
751
- output,
752
- parsedBody: parsedBody.Error,
753
- errorCode,
754
- });
755
- };
756
523
  export const de_DisableInsightRulesCommand = async (output, context) => {
757
524
  if (output.statusCode >= 300) {
758
- return de_DisableInsightRulesCommandError(output, context);
525
+ return de_CommandError(output, context);
759
526
  }
760
527
  const data = await parseBody(output.body, context);
761
528
  let contents = {};
@@ -766,31 +533,9 @@ export const de_DisableInsightRulesCommand = async (output, context) => {
766
533
  };
767
534
  return response;
768
535
  };
769
- const de_DisableInsightRulesCommandError = async (output, context) => {
770
- const parsedOutput = {
771
- ...output,
772
- body: await parseErrorBody(output.body, context),
773
- };
774
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
775
- switch (errorCode) {
776
- case "InvalidParameterValue":
777
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
778
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
779
- case "MissingParameter":
780
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
781
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
782
- default:
783
- const parsedBody = parsedOutput.body;
784
- return throwDefaultError({
785
- output,
786
- parsedBody: parsedBody.Error,
787
- errorCode,
788
- });
789
- }
790
- };
791
536
  export const de_EnableAlarmActionsCommand = async (output, context) => {
792
537
  if (output.statusCode >= 300) {
793
- return de_EnableAlarmActionsCommandError(output, context);
538
+ return de_CommandError(output, context);
794
539
  }
795
540
  await collectBody(output.body, context);
796
541
  const response = {
@@ -798,22 +543,9 @@ export const de_EnableAlarmActionsCommand = async (output, context) => {
798
543
  };
799
544
  return response;
800
545
  };
801
- const de_EnableAlarmActionsCommandError = async (output, context) => {
802
- const parsedOutput = {
803
- ...output,
804
- body: await parseErrorBody(output.body, context),
805
- };
806
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
807
- const parsedBody = parsedOutput.body;
808
- return throwDefaultError({
809
- output,
810
- parsedBody: parsedBody.Error,
811
- errorCode,
812
- });
813
- };
814
546
  export const de_EnableInsightRulesCommand = async (output, context) => {
815
547
  if (output.statusCode >= 300) {
816
- return de_EnableInsightRulesCommandError(output, context);
548
+ return de_CommandError(output, context);
817
549
  }
818
550
  const data = await parseBody(output.body, context);
819
551
  let contents = {};
@@ -824,72 +556,22 @@ export const de_EnableInsightRulesCommand = async (output, context) => {
824
556
  };
825
557
  return response;
826
558
  };
827
- const de_EnableInsightRulesCommandError = async (output, context) => {
828
- const parsedOutput = {
829
- ...output,
830
- body: await parseErrorBody(output.body, context),
831
- };
832
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
833
- switch (errorCode) {
834
- case "InvalidParameterValue":
835
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
836
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
837
- case "LimitExceededException":
838
- case "com.amazonaws.cloudwatch#LimitExceededException":
839
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
840
- case "MissingParameter":
841
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
842
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
843
- default:
844
- const parsedBody = parsedOutput.body;
845
- return throwDefaultError({
846
- output,
847
- parsedBody: parsedBody.Error,
848
- errorCode,
849
- });
850
- }
851
- };
852
- export const de_GetDashboardCommand = async (output, context) => {
853
- if (output.statusCode >= 300) {
854
- return de_GetDashboardCommandError(output, context);
855
- }
856
- const data = await parseBody(output.body, context);
857
- let contents = {};
858
- contents = de_GetDashboardOutput(data.GetDashboardResult, context);
859
- const response = {
860
- $metadata: deserializeMetadata(output),
861
- ...contents,
559
+ export const de_GetDashboardCommand = async (output, context) => {
560
+ if (output.statusCode >= 300) {
561
+ return de_CommandError(output, context);
562
+ }
563
+ const data = await parseBody(output.body, context);
564
+ let contents = {};
565
+ contents = de_GetDashboardOutput(data.GetDashboardResult, context);
566
+ const response = {
567
+ $metadata: deserializeMetadata(output),
568
+ ...contents,
862
569
  };
863
570
  return response;
864
571
  };
865
- const de_GetDashboardCommandError = async (output, context) => {
866
- const parsedOutput = {
867
- ...output,
868
- body: await parseErrorBody(output.body, context),
869
- };
870
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
871
- switch (errorCode) {
872
- case "InternalServiceError":
873
- case "com.amazonaws.cloudwatch#InternalServiceFault":
874
- throw await de_InternalServiceFaultRes(parsedOutput, context);
875
- case "InvalidParameterValue":
876
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
877
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
878
- case "ResourceNotFound":
879
- case "com.amazonaws.cloudwatch#DashboardNotFoundError":
880
- throw await de_DashboardNotFoundErrorRes(parsedOutput, context);
881
- default:
882
- const parsedBody = parsedOutput.body;
883
- return throwDefaultError({
884
- output,
885
- parsedBody: parsedBody.Error,
886
- errorCode,
887
- });
888
- }
889
- };
890
572
  export const de_GetInsightRuleReportCommand = async (output, context) => {
891
573
  if (output.statusCode >= 300) {
892
- return de_GetInsightRuleReportCommandError(output, context);
574
+ return de_CommandError(output, context);
893
575
  }
894
576
  const data = await parseBody(output.body, context);
895
577
  let contents = {};
@@ -900,34 +582,9 @@ export const de_GetInsightRuleReportCommand = async (output, context) => {
900
582
  };
901
583
  return response;
902
584
  };
903
- const de_GetInsightRuleReportCommandError = async (output, context) => {
904
- const parsedOutput = {
905
- ...output,
906
- body: await parseErrorBody(output.body, context),
907
- };
908
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
909
- switch (errorCode) {
910
- case "InvalidParameterValue":
911
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
912
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
913
- case "MissingParameter":
914
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
915
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
916
- case "ResourceNotFoundException":
917
- case "com.amazonaws.cloudwatch#ResourceNotFoundException":
918
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
919
- default:
920
- const parsedBody = parsedOutput.body;
921
- return throwDefaultError({
922
- output,
923
- parsedBody: parsedBody.Error,
924
- errorCode,
925
- });
926
- }
927
- };
928
585
  export const de_GetMetricDataCommand = async (output, context) => {
929
586
  if (output.statusCode >= 300) {
930
- return de_GetMetricDataCommandError(output, context);
587
+ return de_CommandError(output, context);
931
588
  }
932
589
  const data = await parseBody(output.body, context);
933
590
  let contents = {};
@@ -938,28 +595,9 @@ export const de_GetMetricDataCommand = async (output, context) => {
938
595
  };
939
596
  return response;
940
597
  };
941
- const de_GetMetricDataCommandError = async (output, context) => {
942
- const parsedOutput = {
943
- ...output,
944
- body: await parseErrorBody(output.body, context),
945
- };
946
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
947
- switch (errorCode) {
948
- case "InvalidNextToken":
949
- case "com.amazonaws.cloudwatch#InvalidNextToken":
950
- throw await de_InvalidNextTokenRes(parsedOutput, context);
951
- default:
952
- const parsedBody = parsedOutput.body;
953
- return throwDefaultError({
954
- output,
955
- parsedBody: parsedBody.Error,
956
- errorCode,
957
- });
958
- }
959
- };
960
598
  export const de_GetMetricStatisticsCommand = async (output, context) => {
961
599
  if (output.statusCode >= 300) {
962
- return de_GetMetricStatisticsCommandError(output, context);
600
+ return de_CommandError(output, context);
963
601
  }
964
602
  const data = await parseBody(output.body, context);
965
603
  let contents = {};
@@ -970,37 +608,9 @@ export const de_GetMetricStatisticsCommand = async (output, context) => {
970
608
  };
971
609
  return response;
972
610
  };
973
- const de_GetMetricStatisticsCommandError = async (output, context) => {
974
- const parsedOutput = {
975
- ...output,
976
- body: await parseErrorBody(output.body, context),
977
- };
978
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
979
- switch (errorCode) {
980
- case "InternalServiceError":
981
- case "com.amazonaws.cloudwatch#InternalServiceFault":
982
- throw await de_InternalServiceFaultRes(parsedOutput, context);
983
- case "InvalidParameterCombination":
984
- case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
985
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
986
- case "InvalidParameterValue":
987
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
988
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
989
- case "MissingParameter":
990
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
991
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
992
- default:
993
- const parsedBody = parsedOutput.body;
994
- return throwDefaultError({
995
- output,
996
- parsedBody: parsedBody.Error,
997
- errorCode,
998
- });
999
- }
1000
- };
1001
611
  export const de_GetMetricStreamCommand = async (output, context) => {
1002
612
  if (output.statusCode >= 300) {
1003
- return de_GetMetricStreamCommandError(output, context);
613
+ return de_CommandError(output, context);
1004
614
  }
1005
615
  const data = await parseBody(output.body, context);
1006
616
  let contents = {};
@@ -1011,40 +621,9 @@ export const de_GetMetricStreamCommand = async (output, context) => {
1011
621
  };
1012
622
  return response;
1013
623
  };
1014
- const de_GetMetricStreamCommandError = async (output, context) => {
1015
- const parsedOutput = {
1016
- ...output,
1017
- body: await parseErrorBody(output.body, context),
1018
- };
1019
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1020
- switch (errorCode) {
1021
- case "InternalServiceError":
1022
- case "com.amazonaws.cloudwatch#InternalServiceFault":
1023
- throw await de_InternalServiceFaultRes(parsedOutput, context);
1024
- case "InvalidParameterCombination":
1025
- case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
1026
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
1027
- case "InvalidParameterValue":
1028
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
1029
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1030
- case "MissingParameter":
1031
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
1032
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
1033
- case "ResourceNotFoundException":
1034
- case "com.amazonaws.cloudwatch#ResourceNotFoundException":
1035
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1036
- default:
1037
- const parsedBody = parsedOutput.body;
1038
- return throwDefaultError({
1039
- output,
1040
- parsedBody: parsedBody.Error,
1041
- errorCode,
1042
- });
1043
- }
1044
- };
1045
624
  export const de_GetMetricWidgetImageCommand = async (output, context) => {
1046
625
  if (output.statusCode >= 300) {
1047
- return de_GetMetricWidgetImageCommandError(output, context);
626
+ return de_CommandError(output, context);
1048
627
  }
1049
628
  const data = await parseBody(output.body, context);
1050
629
  let contents = {};
@@ -1055,22 +634,9 @@ export const de_GetMetricWidgetImageCommand = async (output, context) => {
1055
634
  };
1056
635
  return response;
1057
636
  };
1058
- const de_GetMetricWidgetImageCommandError = async (output, context) => {
1059
- const parsedOutput = {
1060
- ...output,
1061
- body: await parseErrorBody(output.body, context),
1062
- };
1063
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1064
- const parsedBody = parsedOutput.body;
1065
- return throwDefaultError({
1066
- output,
1067
- parsedBody: parsedBody.Error,
1068
- errorCode,
1069
- });
1070
- };
1071
637
  export const de_ListDashboardsCommand = async (output, context) => {
1072
638
  if (output.statusCode >= 300) {
1073
- return de_ListDashboardsCommandError(output, context);
639
+ return de_CommandError(output, context);
1074
640
  }
1075
641
  const data = await parseBody(output.body, context);
1076
642
  let contents = {};
@@ -1081,31 +647,9 @@ export const de_ListDashboardsCommand = async (output, context) => {
1081
647
  };
1082
648
  return response;
1083
649
  };
1084
- const de_ListDashboardsCommandError = async (output, context) => {
1085
- const parsedOutput = {
1086
- ...output,
1087
- body: await parseErrorBody(output.body, context),
1088
- };
1089
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1090
- switch (errorCode) {
1091
- case "InternalServiceError":
1092
- case "com.amazonaws.cloudwatch#InternalServiceFault":
1093
- throw await de_InternalServiceFaultRes(parsedOutput, context);
1094
- case "InvalidParameterValue":
1095
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
1096
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1097
- default:
1098
- const parsedBody = parsedOutput.body;
1099
- return throwDefaultError({
1100
- output,
1101
- parsedBody: parsedBody.Error,
1102
- errorCode,
1103
- });
1104
- }
1105
- };
1106
650
  export const de_ListManagedInsightRulesCommand = async (output, context) => {
1107
651
  if (output.statusCode >= 300) {
1108
- return de_ListManagedInsightRulesCommandError(output, context);
652
+ return de_CommandError(output, context);
1109
653
  }
1110
654
  const data = await parseBody(output.body, context);
1111
655
  let contents = {};
@@ -1116,34 +660,9 @@ export const de_ListManagedInsightRulesCommand = async (output, context) => {
1116
660
  };
1117
661
  return response;
1118
662
  };
1119
- const de_ListManagedInsightRulesCommandError = async (output, context) => {
1120
- const parsedOutput = {
1121
- ...output,
1122
- body: await parseErrorBody(output.body, context),
1123
- };
1124
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1125
- switch (errorCode) {
1126
- case "InvalidNextToken":
1127
- case "com.amazonaws.cloudwatch#InvalidNextToken":
1128
- throw await de_InvalidNextTokenRes(parsedOutput, context);
1129
- case "InvalidParameterValue":
1130
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
1131
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1132
- case "MissingParameter":
1133
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
1134
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
1135
- default:
1136
- const parsedBody = parsedOutput.body;
1137
- return throwDefaultError({
1138
- output,
1139
- parsedBody: parsedBody.Error,
1140
- errorCode,
1141
- });
1142
- }
1143
- };
1144
663
  export const de_ListMetricsCommand = async (output, context) => {
1145
664
  if (output.statusCode >= 300) {
1146
- return de_ListMetricsCommandError(output, context);
665
+ return de_CommandError(output, context);
1147
666
  }
1148
667
  const data = await parseBody(output.body, context);
1149
668
  let contents = {};
@@ -1154,31 +673,9 @@ export const de_ListMetricsCommand = async (output, context) => {
1154
673
  };
1155
674
  return response;
1156
675
  };
1157
- const de_ListMetricsCommandError = async (output, context) => {
1158
- const parsedOutput = {
1159
- ...output,
1160
- body: await parseErrorBody(output.body, context),
1161
- };
1162
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1163
- switch (errorCode) {
1164
- case "InternalServiceError":
1165
- case "com.amazonaws.cloudwatch#InternalServiceFault":
1166
- throw await de_InternalServiceFaultRes(parsedOutput, context);
1167
- case "InvalidParameterValue":
1168
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
1169
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1170
- default:
1171
- const parsedBody = parsedOutput.body;
1172
- return throwDefaultError({
1173
- output,
1174
- parsedBody: parsedBody.Error,
1175
- errorCode,
1176
- });
1177
- }
1178
- };
1179
676
  export const de_ListMetricStreamsCommand = async (output, context) => {
1180
677
  if (output.statusCode >= 300) {
1181
- return de_ListMetricStreamsCommandError(output, context);
678
+ return de_CommandError(output, context);
1182
679
  }
1183
680
  const data = await parseBody(output.body, context);
1184
681
  let contents = {};
@@ -1189,37 +686,9 @@ export const de_ListMetricStreamsCommand = async (output, context) => {
1189
686
  };
1190
687
  return response;
1191
688
  };
1192
- const de_ListMetricStreamsCommandError = async (output, context) => {
1193
- const parsedOutput = {
1194
- ...output,
1195
- body: await parseErrorBody(output.body, context),
1196
- };
1197
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1198
- switch (errorCode) {
1199
- case "InternalServiceError":
1200
- case "com.amazonaws.cloudwatch#InternalServiceFault":
1201
- throw await de_InternalServiceFaultRes(parsedOutput, context);
1202
- case "InvalidNextToken":
1203
- case "com.amazonaws.cloudwatch#InvalidNextToken":
1204
- throw await de_InvalidNextTokenRes(parsedOutput, context);
1205
- case "InvalidParameterValue":
1206
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
1207
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1208
- case "MissingParameter":
1209
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
1210
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
1211
- default:
1212
- const parsedBody = parsedOutput.body;
1213
- return throwDefaultError({
1214
- output,
1215
- parsedBody: parsedBody.Error,
1216
- errorCode,
1217
- });
1218
- }
1219
- };
1220
689
  export const de_ListTagsForResourceCommand = async (output, context) => {
1221
690
  if (output.statusCode >= 300) {
1222
- return de_ListTagsForResourceCommandError(output, context);
691
+ return de_CommandError(output, context);
1223
692
  }
1224
693
  const data = await parseBody(output.body, context);
1225
694
  let contents = {};
@@ -1230,34 +699,9 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
1230
699
  };
1231
700
  return response;
1232
701
  };
1233
- const de_ListTagsForResourceCommandError = async (output, context) => {
1234
- const parsedOutput = {
1235
- ...output,
1236
- body: await parseErrorBody(output.body, context),
1237
- };
1238
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1239
- switch (errorCode) {
1240
- case "InternalServiceError":
1241
- case "com.amazonaws.cloudwatch#InternalServiceFault":
1242
- throw await de_InternalServiceFaultRes(parsedOutput, context);
1243
- case "InvalidParameterValue":
1244
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
1245
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1246
- case "ResourceNotFoundException":
1247
- case "com.amazonaws.cloudwatch#ResourceNotFoundException":
1248
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1249
- default:
1250
- const parsedBody = parsedOutput.body;
1251
- return throwDefaultError({
1252
- output,
1253
- parsedBody: parsedBody.Error,
1254
- errorCode,
1255
- });
1256
- }
1257
- };
1258
702
  export const de_PutAnomalyDetectorCommand = async (output, context) => {
1259
703
  if (output.statusCode >= 300) {
1260
- return de_PutAnomalyDetectorCommandError(output, context);
704
+ return de_CommandError(output, context);
1261
705
  }
1262
706
  const data = await parseBody(output.body, context);
1263
707
  let contents = {};
@@ -1268,40 +712,9 @@ export const de_PutAnomalyDetectorCommand = async (output, context) => {
1268
712
  };
1269
713
  return response;
1270
714
  };
1271
- const de_PutAnomalyDetectorCommandError = async (output, context) => {
1272
- const parsedOutput = {
1273
- ...output,
1274
- body: await parseErrorBody(output.body, context),
1275
- };
1276
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1277
- switch (errorCode) {
1278
- case "InternalServiceError":
1279
- case "com.amazonaws.cloudwatch#InternalServiceFault":
1280
- throw await de_InternalServiceFaultRes(parsedOutput, context);
1281
- case "InvalidParameterCombination":
1282
- case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
1283
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
1284
- case "InvalidParameterValue":
1285
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
1286
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1287
- case "LimitExceededException":
1288
- case "com.amazonaws.cloudwatch#LimitExceededException":
1289
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1290
- case "MissingParameter":
1291
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
1292
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
1293
- default:
1294
- const parsedBody = parsedOutput.body;
1295
- return throwDefaultError({
1296
- output,
1297
- parsedBody: parsedBody.Error,
1298
- errorCode,
1299
- });
1300
- }
1301
- };
1302
715
  export const de_PutCompositeAlarmCommand = async (output, context) => {
1303
716
  if (output.statusCode >= 300) {
1304
- return de_PutCompositeAlarmCommandError(output, context);
717
+ return de_CommandError(output, context);
1305
718
  }
1306
719
  await collectBody(output.body, context);
1307
720
  const response = {
@@ -1309,136 +722,48 @@ export const de_PutCompositeAlarmCommand = async (output, context) => {
1309
722
  };
1310
723
  return response;
1311
724
  };
1312
- const de_PutCompositeAlarmCommandError = async (output, context) => {
1313
- const parsedOutput = {
1314
- ...output,
1315
- body: await parseErrorBody(output.body, context),
1316
- };
1317
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1318
- switch (errorCode) {
1319
- case "LimitExceeded":
1320
- case "com.amazonaws.cloudwatch#LimitExceededFault":
1321
- throw await de_LimitExceededFaultRes(parsedOutput, context);
1322
- default:
1323
- const parsedBody = parsedOutput.body;
1324
- return throwDefaultError({
1325
- output,
1326
- parsedBody: parsedBody.Error,
1327
- errorCode,
1328
- });
1329
- }
1330
- };
1331
- export const de_PutDashboardCommand = async (output, context) => {
1332
- if (output.statusCode >= 300) {
1333
- return de_PutDashboardCommandError(output, context);
1334
- }
1335
- const data = await parseBody(output.body, context);
1336
- let contents = {};
1337
- contents = de_PutDashboardOutput(data.PutDashboardResult, context);
1338
- const response = {
1339
- $metadata: deserializeMetadata(output),
1340
- ...contents,
1341
- };
1342
- return response;
1343
- };
1344
- const de_PutDashboardCommandError = async (output, context) => {
1345
- const parsedOutput = {
1346
- ...output,
1347
- body: await parseErrorBody(output.body, context),
1348
- };
1349
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1350
- switch (errorCode) {
1351
- case "InternalServiceError":
1352
- case "com.amazonaws.cloudwatch#InternalServiceFault":
1353
- throw await de_InternalServiceFaultRes(parsedOutput, context);
1354
- case "InvalidParameterInput":
1355
- case "com.amazonaws.cloudwatch#DashboardInvalidInputError":
1356
- throw await de_DashboardInvalidInputErrorRes(parsedOutput, context);
1357
- default:
1358
- const parsedBody = parsedOutput.body;
1359
- return throwDefaultError({
1360
- output,
1361
- parsedBody: parsedBody.Error,
1362
- errorCode,
1363
- });
1364
- }
1365
- };
1366
- export const de_PutInsightRuleCommand = async (output, context) => {
1367
- if (output.statusCode >= 300) {
1368
- return de_PutInsightRuleCommandError(output, context);
1369
- }
1370
- const data = await parseBody(output.body, context);
1371
- let contents = {};
1372
- contents = de_PutInsightRuleOutput(data.PutInsightRuleResult, context);
1373
- const response = {
1374
- $metadata: deserializeMetadata(output),
1375
- ...contents,
1376
- };
1377
- return response;
1378
- };
1379
- const de_PutInsightRuleCommandError = async (output, context) => {
1380
- const parsedOutput = {
1381
- ...output,
1382
- body: await parseErrorBody(output.body, context),
1383
- };
1384
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1385
- switch (errorCode) {
1386
- case "InvalidParameterValue":
1387
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
1388
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1389
- case "LimitExceededException":
1390
- case "com.amazonaws.cloudwatch#LimitExceededException":
1391
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1392
- case "MissingParameter":
1393
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
1394
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
1395
- default:
1396
- const parsedBody = parsedOutput.body;
1397
- return throwDefaultError({
1398
- output,
1399
- parsedBody: parsedBody.Error,
1400
- errorCode,
1401
- });
1402
- }
1403
- };
1404
- export const de_PutManagedInsightRulesCommand = async (output, context) => {
725
+ export const de_PutDashboardCommand = async (output, context) => {
1405
726
  if (output.statusCode >= 300) {
1406
- return de_PutManagedInsightRulesCommandError(output, context);
727
+ return de_CommandError(output, context);
1407
728
  }
1408
729
  const data = await parseBody(output.body, context);
1409
730
  let contents = {};
1410
- contents = de_PutManagedInsightRulesOutput(data.PutManagedInsightRulesResult, context);
731
+ contents = de_PutDashboardOutput(data.PutDashboardResult, context);
1411
732
  const response = {
1412
733
  $metadata: deserializeMetadata(output),
1413
734
  ...contents,
1414
735
  };
1415
736
  return response;
1416
737
  };
1417
- const de_PutManagedInsightRulesCommandError = async (output, context) => {
1418
- const parsedOutput = {
1419
- ...output,
1420
- body: await parseErrorBody(output.body, context),
738
+ export const de_PutInsightRuleCommand = async (output, context) => {
739
+ if (output.statusCode >= 300) {
740
+ return de_CommandError(output, context);
741
+ }
742
+ const data = await parseBody(output.body, context);
743
+ let contents = {};
744
+ contents = de_PutInsightRuleOutput(data.PutInsightRuleResult, context);
745
+ const response = {
746
+ $metadata: deserializeMetadata(output),
747
+ ...contents,
1421
748
  };
1422
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1423
- switch (errorCode) {
1424
- case "InvalidParameterValue":
1425
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
1426
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1427
- case "MissingParameter":
1428
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
1429
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
1430
- default:
1431
- const parsedBody = parsedOutput.body;
1432
- return throwDefaultError({
1433
- output,
1434
- parsedBody: parsedBody.Error,
1435
- errorCode,
1436
- });
749
+ return response;
750
+ };
751
+ export const de_PutManagedInsightRulesCommand = async (output, context) => {
752
+ if (output.statusCode >= 300) {
753
+ return de_CommandError(output, context);
1437
754
  }
755
+ const data = await parseBody(output.body, context);
756
+ let contents = {};
757
+ contents = de_PutManagedInsightRulesOutput(data.PutManagedInsightRulesResult, context);
758
+ const response = {
759
+ $metadata: deserializeMetadata(output),
760
+ ...contents,
761
+ };
762
+ return response;
1438
763
  };
1439
764
  export const de_PutMetricAlarmCommand = async (output, context) => {
1440
765
  if (output.statusCode >= 300) {
1441
- return de_PutMetricAlarmCommandError(output, context);
766
+ return de_CommandError(output, context);
1442
767
  }
1443
768
  await collectBody(output.body, context);
1444
769
  const response = {
@@ -1446,28 +771,9 @@ export const de_PutMetricAlarmCommand = async (output, context) => {
1446
771
  };
1447
772
  return response;
1448
773
  };
1449
- const de_PutMetricAlarmCommandError = async (output, context) => {
1450
- const parsedOutput = {
1451
- ...output,
1452
- body: await parseErrorBody(output.body, context),
1453
- };
1454
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1455
- switch (errorCode) {
1456
- case "LimitExceeded":
1457
- case "com.amazonaws.cloudwatch#LimitExceededFault":
1458
- throw await de_LimitExceededFaultRes(parsedOutput, context);
1459
- default:
1460
- const parsedBody = parsedOutput.body;
1461
- return throwDefaultError({
1462
- output,
1463
- parsedBody: parsedBody.Error,
1464
- errorCode,
1465
- });
1466
- }
1467
- };
1468
774
  export const de_PutMetricDataCommand = async (output, context) => {
1469
775
  if (output.statusCode >= 300) {
1470
- return de_PutMetricDataCommandError(output, context);
776
+ return de_CommandError(output, context);
1471
777
  }
1472
778
  await collectBody(output.body, context);
1473
779
  const response = {
@@ -1475,37 +781,9 @@ export const de_PutMetricDataCommand = async (output, context) => {
1475
781
  };
1476
782
  return response;
1477
783
  };
1478
- const de_PutMetricDataCommandError = async (output, context) => {
1479
- const parsedOutput = {
1480
- ...output,
1481
- body: await parseErrorBody(output.body, context),
1482
- };
1483
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1484
- switch (errorCode) {
1485
- case "InternalServiceError":
1486
- case "com.amazonaws.cloudwatch#InternalServiceFault":
1487
- throw await de_InternalServiceFaultRes(parsedOutput, context);
1488
- case "InvalidParameterCombination":
1489
- case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
1490
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
1491
- case "InvalidParameterValue":
1492
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
1493
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1494
- case "MissingParameter":
1495
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
1496
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
1497
- default:
1498
- const parsedBody = parsedOutput.body;
1499
- return throwDefaultError({
1500
- output,
1501
- parsedBody: parsedBody.Error,
1502
- errorCode,
1503
- });
1504
- }
1505
- };
1506
784
  export const de_PutMetricStreamCommand = async (output, context) => {
1507
785
  if (output.statusCode >= 300) {
1508
- return de_PutMetricStreamCommandError(output, context);
786
+ return de_CommandError(output, context);
1509
787
  }
1510
788
  const data = await parseBody(output.body, context);
1511
789
  let contents = {};
@@ -1516,40 +794,9 @@ export const de_PutMetricStreamCommand = async (output, context) => {
1516
794
  };
1517
795
  return response;
1518
796
  };
1519
- const de_PutMetricStreamCommandError = async (output, context) => {
1520
- const parsedOutput = {
1521
- ...output,
1522
- body: await parseErrorBody(output.body, context),
1523
- };
1524
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1525
- switch (errorCode) {
1526
- case "ConcurrentModificationException":
1527
- case "com.amazonaws.cloudwatch#ConcurrentModificationException":
1528
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1529
- case "InternalServiceError":
1530
- case "com.amazonaws.cloudwatch#InternalServiceFault":
1531
- throw await de_InternalServiceFaultRes(parsedOutput, context);
1532
- case "InvalidParameterCombination":
1533
- case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
1534
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
1535
- case "InvalidParameterValue":
1536
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
1537
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1538
- case "MissingParameter":
1539
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
1540
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
1541
- default:
1542
- const parsedBody = parsedOutput.body;
1543
- return throwDefaultError({
1544
- output,
1545
- parsedBody: parsedBody.Error,
1546
- errorCode,
1547
- });
1548
- }
1549
- };
1550
797
  export const de_SetAlarmStateCommand = async (output, context) => {
1551
798
  if (output.statusCode >= 300) {
1552
- return de_SetAlarmStateCommandError(output, context);
799
+ return de_CommandError(output, context);
1553
800
  }
1554
801
  await collectBody(output.body, context);
1555
802
  const response = {
@@ -1557,31 +804,9 @@ export const de_SetAlarmStateCommand = async (output, context) => {
1557
804
  };
1558
805
  return response;
1559
806
  };
1560
- const de_SetAlarmStateCommandError = async (output, context) => {
1561
- const parsedOutput = {
1562
- ...output,
1563
- body: await parseErrorBody(output.body, context),
1564
- };
1565
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1566
- switch (errorCode) {
1567
- case "InvalidFormat":
1568
- case "com.amazonaws.cloudwatch#InvalidFormatFault":
1569
- throw await de_InvalidFormatFaultRes(parsedOutput, context);
1570
- case "ResourceNotFound":
1571
- case "com.amazonaws.cloudwatch#ResourceNotFound":
1572
- throw await de_ResourceNotFoundRes(parsedOutput, context);
1573
- default:
1574
- const parsedBody = parsedOutput.body;
1575
- return throwDefaultError({
1576
- output,
1577
- parsedBody: parsedBody.Error,
1578
- errorCode,
1579
- });
1580
- }
1581
- };
1582
807
  export const de_StartMetricStreamsCommand = async (output, context) => {
1583
808
  if (output.statusCode >= 300) {
1584
- return de_StartMetricStreamsCommandError(output, context);
809
+ return de_CommandError(output, context);
1585
810
  }
1586
811
  const data = await parseBody(output.body, context);
1587
812
  let contents = {};
@@ -1592,34 +817,9 @@ export const de_StartMetricStreamsCommand = async (output, context) => {
1592
817
  };
1593
818
  return response;
1594
819
  };
1595
- const de_StartMetricStreamsCommandError = async (output, context) => {
1596
- const parsedOutput = {
1597
- ...output,
1598
- body: await parseErrorBody(output.body, context),
1599
- };
1600
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1601
- switch (errorCode) {
1602
- case "InternalServiceError":
1603
- case "com.amazonaws.cloudwatch#InternalServiceFault":
1604
- throw await de_InternalServiceFaultRes(parsedOutput, context);
1605
- case "InvalidParameterValue":
1606
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
1607
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1608
- case "MissingParameter":
1609
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
1610
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
1611
- default:
1612
- const parsedBody = parsedOutput.body;
1613
- return throwDefaultError({
1614
- output,
1615
- parsedBody: parsedBody.Error,
1616
- errorCode,
1617
- });
1618
- }
1619
- };
1620
820
  export const de_StopMetricStreamsCommand = async (output, context) => {
1621
821
  if (output.statusCode >= 300) {
1622
- return de_StopMetricStreamsCommandError(output, context);
822
+ return de_CommandError(output, context);
1623
823
  }
1624
824
  const data = await parseBody(output.body, context);
1625
825
  let contents = {};
@@ -1630,34 +830,9 @@ export const de_StopMetricStreamsCommand = async (output, context) => {
1630
830
  };
1631
831
  return response;
1632
832
  };
1633
- const de_StopMetricStreamsCommandError = async (output, context) => {
1634
- const parsedOutput = {
1635
- ...output,
1636
- body: await parseErrorBody(output.body, context),
1637
- };
1638
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1639
- switch (errorCode) {
1640
- case "InternalServiceError":
1641
- case "com.amazonaws.cloudwatch#InternalServiceFault":
1642
- throw await de_InternalServiceFaultRes(parsedOutput, context);
1643
- case "InvalidParameterValue":
1644
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
1645
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1646
- case "MissingParameter":
1647
- case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
1648
- throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
1649
- default:
1650
- const parsedBody = parsedOutput.body;
1651
- return throwDefaultError({
1652
- output,
1653
- parsedBody: parsedBody.Error,
1654
- errorCode,
1655
- });
1656
- }
1657
- };
1658
833
  export const de_TagResourceCommand = async (output, context) => {
1659
834
  if (output.statusCode >= 300) {
1660
- return de_TagResourceCommandError(output, context);
835
+ return de_CommandError(output, context);
1661
836
  }
1662
837
  const data = await parseBody(output.body, context);
1663
838
  let contents = {};
@@ -1668,37 +843,9 @@ export const de_TagResourceCommand = async (output, context) => {
1668
843
  };
1669
844
  return response;
1670
845
  };
1671
- const de_TagResourceCommandError = async (output, context) => {
1672
- const parsedOutput = {
1673
- ...output,
1674
- body: await parseErrorBody(output.body, context),
1675
- };
1676
- const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1677
- switch (errorCode) {
1678
- case "ConcurrentModificationException":
1679
- case "com.amazonaws.cloudwatch#ConcurrentModificationException":
1680
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1681
- case "InternalServiceError":
1682
- case "com.amazonaws.cloudwatch#InternalServiceFault":
1683
- throw await de_InternalServiceFaultRes(parsedOutput, context);
1684
- case "InvalidParameterValue":
1685
- case "com.amazonaws.cloudwatch#InvalidParameterValueException":
1686
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1687
- case "ResourceNotFoundException":
1688
- case "com.amazonaws.cloudwatch#ResourceNotFoundException":
1689
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1690
- default:
1691
- const parsedBody = parsedOutput.body;
1692
- return throwDefaultError({
1693
- output,
1694
- parsedBody: parsedBody.Error,
1695
- errorCode,
1696
- });
1697
- }
1698
- };
1699
846
  export const de_UntagResourceCommand = async (output, context) => {
1700
847
  if (output.statusCode >= 300) {
1701
- return de_UntagResourceCommandError(output, context);
848
+ return de_CommandError(output, context);
1702
849
  }
1703
850
  const data = await parseBody(output.body, context);
1704
851
  let contents = {};
@@ -1709,25 +856,49 @@ export const de_UntagResourceCommand = async (output, context) => {
1709
856
  };
1710
857
  return response;
1711
858
  };
1712
- const de_UntagResourceCommandError = async (output, context) => {
859
+ const de_CommandError = async (output, context) => {
1713
860
  const parsedOutput = {
1714
861
  ...output,
1715
862
  body: await parseErrorBody(output.body, context),
1716
863
  };
1717
864
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1718
865
  switch (errorCode) {
1719
- case "ConcurrentModificationException":
1720
- case "com.amazonaws.cloudwatch#ConcurrentModificationException":
1721
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
866
+ case "ResourceNotFound":
867
+ case "com.amazonaws.cloudwatch#ResourceNotFound":
868
+ throw await de_ResourceNotFoundRes(parsedOutput, context);
1722
869
  case "InternalServiceError":
1723
870
  case "com.amazonaws.cloudwatch#InternalServiceFault":
1724
871
  throw await de_InternalServiceFaultRes(parsedOutput, context);
872
+ case "InvalidParameterCombination":
873
+ case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
874
+ throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
1725
875
  case "InvalidParameterValue":
1726
876
  case "com.amazonaws.cloudwatch#InvalidParameterValueException":
1727
877
  throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
878
+ case "MissingParameter":
879
+ case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
880
+ throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
1728
881
  case "ResourceNotFoundException":
1729
882
  case "com.amazonaws.cloudwatch#ResourceNotFoundException":
1730
883
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
884
+ case "InvalidNextToken":
885
+ case "com.amazonaws.cloudwatch#InvalidNextToken":
886
+ throw await de_InvalidNextTokenRes(parsedOutput, context);
887
+ case "LimitExceededException":
888
+ case "com.amazonaws.cloudwatch#LimitExceededException":
889
+ throw await de_LimitExceededExceptionRes(parsedOutput, context);
890
+ case "LimitExceeded":
891
+ case "com.amazonaws.cloudwatch#LimitExceededFault":
892
+ throw await de_LimitExceededFaultRes(parsedOutput, context);
893
+ case "InvalidParameterInput":
894
+ case "com.amazonaws.cloudwatch#DashboardInvalidInputError":
895
+ throw await de_DashboardInvalidInputErrorRes(parsedOutput, context);
896
+ case "ConcurrentModificationException":
897
+ case "com.amazonaws.cloudwatch#ConcurrentModificationException":
898
+ throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
899
+ case "InvalidFormat":
900
+ case "com.amazonaws.cloudwatch#InvalidFormatFault":
901
+ throw await de_InvalidFormatFaultRes(parsedOutput, context);
1731
902
  default:
1732
903
  const parsedBody = parsedOutput.body;
1733
904
  return throwDefaultError({
@@ -1755,15 +926,6 @@ const de_DashboardInvalidInputErrorRes = async (parsedOutput, context) => {
1755
926
  });
1756
927
  return __decorateServiceException(exception, body);
1757
928
  };
1758
- const de_DashboardNotFoundErrorRes = async (parsedOutput, context) => {
1759
- const body = parsedOutput.body;
1760
- const deserialized = de_DashboardNotFoundError(body.Error, context);
1761
- const exception = new DashboardNotFoundError({
1762
- $metadata: deserializeMetadata(parsedOutput),
1763
- ...deserialized,
1764
- });
1765
- return __decorateServiceException(exception, body);
1766
- };
1767
929
  const de_InternalServiceFaultRes = async (parsedOutput, context) => {
1768
930
  const body = parsedOutput.body;
1769
931
  const deserialized = de_InternalServiceFault(body.Error, context);
@@ -3649,13 +2811,6 @@ const de_DashboardInvalidInputError = (output, context) => {
3649
2811
  }
3650
2812
  return contents;
3651
2813
  };
3652
- const de_DashboardNotFoundError = (output, context) => {
3653
- const contents = {};
3654
- if (output[_me] != null) {
3655
- contents[_me] = __expectString(output[_me]);
3656
- }
3657
- return contents;
3658
- };
3659
2814
  const de_DashboardValidationMessage = (output, context) => {
3660
2815
  const contents = {};
3661
2816
  if (output[_DP] != null) {