@aws-sdk/client-chime-sdk-messaging 3.52.0 → 3.53.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 (16) hide show
  1. package/CHANGELOG.md +11 -0
  2. package/dist-cjs/index.js +3 -0
  3. package/dist-cjs/models/ChimeSDKMessagingServiceException.js +11 -0
  4. package/dist-cjs/models/models_0.js +139 -3
  5. package/dist-cjs/protocols/Aws_restJson1.js +561 -2318
  6. package/dist-es/index.js +1 -0
  7. package/dist-es/models/ChimeSDKMessagingServiceException.js +12 -0
  8. package/dist-es/models/models_0.js +128 -1
  9. package/dist-es/protocols/Aws_restJson1.js +1201 -2508
  10. package/dist-types/index.d.ts +1 -0
  11. package/dist-types/models/ChimeSDKMessagingServiceException.d.ts +10 -0
  12. package/dist-types/models/models_0.d.ts +65 -28
  13. package/dist-types/ts3.4/index.d.ts +1 -0
  14. package/dist-types/ts3.4/models/ChimeSDKMessagingServiceException.d.ts +6 -0
  15. package/dist-types/ts3.4/models/models_0.d.ts +47 -28
  16. package/package.json +25 -25
package/dist-cjs/protocols/Aws_restJson1.js CHANGED
@@ -5,6 +5,8 @@ exports.deserializeAws_restJson1UpdateChannelReadMarkerCommand = exports.deseria
5
5
  const protocol_http_1 = require("@aws-sdk/protocol-http");
6
6
  const smithy_client_1 = require("@aws-sdk/smithy-client");
7
7
  const uuid_1 = require("uuid");
8
+ const ChimeSDKMessagingServiceException_1 = require("../models/ChimeSDKMessagingServiceException");
9
+ const models_0_1 = require("../models/models_0");
8
10
  const serializeAws_restJson1AssociateChannelFlowCommand = async (input, context) => {
9
11
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
10
12
  const headers = {
@@ -1527,83 +1529,37 @@ const deserializeAws_restJson1AssociateChannelFlowCommandError = async (output,
1527
1529
  switch (errorCode) {
1528
1530
  case "BadRequestException":
1529
1531
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
1530
- response = {
1531
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
1532
- name: errorCode,
1533
- $metadata: deserializeMetadata(output),
1534
- };
1535
- break;
1532
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
1536
1533
  case "ConflictException":
1537
1534
  case "com.amazonaws.chimesdkmessaging#ConflictException":
1538
- response = {
1539
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
1540
- name: errorCode,
1541
- $metadata: deserializeMetadata(output),
1542
- };
1543
- break;
1535
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
1544
1536
  case "ForbiddenException":
1545
1537
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
1546
- response = {
1547
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
1548
- name: errorCode,
1549
- $metadata: deserializeMetadata(output),
1550
- };
1551
- break;
1538
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
1552
1539
  case "NotFoundException":
1553
1540
  case "com.amazonaws.chimesdkmessaging#NotFoundException":
1554
- response = {
1555
- ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
1556
- name: errorCode,
1557
- $metadata: deserializeMetadata(output),
1558
- };
1559
- break;
1541
+ throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
1560
1542
  case "ServiceFailureException":
1561
1543
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
1562
- response = {
1563
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
1564
- name: errorCode,
1565
- $metadata: deserializeMetadata(output),
1566
- };
1567
- break;
1544
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
1568
1545
  case "ServiceUnavailableException":
1569
1546
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
1570
- response = {
1571
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
1572
- name: errorCode,
1573
- $metadata: deserializeMetadata(output),
1574
- };
1575
- break;
1547
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
1576
1548
  case "ThrottledClientException":
1577
1549
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
1578
- response = {
1579
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
1580
- name: errorCode,
1581
- $metadata: deserializeMetadata(output),
1582
- };
1583
- break;
1550
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
1584
1551
  case "UnauthorizedClientException":
1585
1552
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
1586
- response = {
1587
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
1588
- name: errorCode,
1589
- $metadata: deserializeMetadata(output),
1590
- };
1591
- break;
1553
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
1592
1554
  default:
1593
1555
  const parsedBody = parsedOutput.body;
1594
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1595
- response = {
1596
- ...parsedBody,
1597
- name: `${errorCode}`,
1598
- message: parsedBody.message || parsedBody.Message || errorCode,
1556
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
1557
+ name: parsedBody.code || parsedBody.Code || errorCode,
1599
1558
  $fault: "client",
1600
1559
  $metadata: deserializeMetadata(output),
1601
- };
1560
+ });
1561
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1602
1562
  }
1603
- const message = response.message || response.Message || errorCode;
1604
- response.message = message;
1605
- delete response.Message;
1606
- return Promise.reject(Object.assign(new Error(message), response));
1607
1563
  };
1608
1564
  const deserializeAws_restJson1BatchCreateChannelMembershipCommand = async (output, context) => {
1609
1565
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1635,67 +1591,31 @@ const deserializeAws_restJson1BatchCreateChannelMembershipCommandError = async (
1635
1591
  switch (errorCode) {
1636
1592
  case "BadRequestException":
1637
1593
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
1638
- response = {
1639
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
1640
- name: errorCode,
1641
- $metadata: deserializeMetadata(output),
1642
- };
1643
- break;
1594
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
1644
1595
  case "ForbiddenException":
1645
1596
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
1646
- response = {
1647
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
1648
- name: errorCode,
1649
- $metadata: deserializeMetadata(output),
1650
- };
1651
- break;
1597
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
1652
1598
  case "ServiceFailureException":
1653
1599
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
1654
- response = {
1655
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
1656
- name: errorCode,
1657
- $metadata: deserializeMetadata(output),
1658
- };
1659
- break;
1600
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
1660
1601
  case "ServiceUnavailableException":
1661
1602
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
1662
- response = {
1663
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
1664
- name: errorCode,
1665
- $metadata: deserializeMetadata(output),
1666
- };
1667
- break;
1603
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
1668
1604
  case "ThrottledClientException":
1669
1605
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
1670
- response = {
1671
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
1672
- name: errorCode,
1673
- $metadata: deserializeMetadata(output),
1674
- };
1675
- break;
1606
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
1676
1607
  case "UnauthorizedClientException":
1677
1608
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
1678
- response = {
1679
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
1680
- name: errorCode,
1681
- $metadata: deserializeMetadata(output),
1682
- };
1683
- break;
1609
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
1684
1610
  default:
1685
1611
  const parsedBody = parsedOutput.body;
1686
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1687
- response = {
1688
- ...parsedBody,
1689
- name: `${errorCode}`,
1690
- message: parsedBody.message || parsedBody.Message || errorCode,
1612
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
1613
+ name: parsedBody.code || parsedBody.Code || errorCode,
1691
1614
  $fault: "client",
1692
1615
  $metadata: deserializeMetadata(output),
1693
- };
1616
+ });
1617
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1694
1618
  }
1695
- const message = response.message || response.Message || errorCode;
1696
- response.message = message;
1697
- delete response.Message;
1698
- return Promise.reject(Object.assign(new Error(message), response));
1699
1619
  };
1700
1620
  const deserializeAws_restJson1ChannelFlowCallbackCommand = async (output, context) => {
1701
1621
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1727,75 +1647,34 @@ const deserializeAws_restJson1ChannelFlowCallbackCommandError = async (output, c
1727
1647
  switch (errorCode) {
1728
1648
  case "BadRequestException":
1729
1649
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
1730
- response = {
1731
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
1732
- name: errorCode,
1733
- $metadata: deserializeMetadata(output),
1734
- };
1735
- break;
1650
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
1736
1651
  case "ConflictException":
1737
1652
  case "com.amazonaws.chimesdkmessaging#ConflictException":
1738
- response = {
1739
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
1740
- name: errorCode,
1741
- $metadata: deserializeMetadata(output),
1742
- };
1743
- break;
1653
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
1744
1654
  case "ForbiddenException":
1745
1655
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
1746
- response = {
1747
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
1748
- name: errorCode,
1749
- $metadata: deserializeMetadata(output),
1750
- };
1751
- break;
1656
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
1752
1657
  case "ServiceFailureException":
1753
1658
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
1754
- response = {
1755
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
1756
- name: errorCode,
1757
- $metadata: deserializeMetadata(output),
1758
- };
1759
- break;
1659
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
1760
1660
  case "ServiceUnavailableException":
1761
1661
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
1762
- response = {
1763
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
1764
- name: errorCode,
1765
- $metadata: deserializeMetadata(output),
1766
- };
1767
- break;
1662
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
1768
1663
  case "ThrottledClientException":
1769
1664
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
1770
- response = {
1771
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
1772
- name: errorCode,
1773
- $metadata: deserializeMetadata(output),
1774
- };
1775
- break;
1665
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
1776
1666
  case "UnauthorizedClientException":
1777
1667
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
1778
- response = {
1779
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
1780
- name: errorCode,
1781
- $metadata: deserializeMetadata(output),
1782
- };
1783
- break;
1668
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
1784
1669
  default:
1785
1670
  const parsedBody = parsedOutput.body;
1786
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1787
- response = {
1788
- ...parsedBody,
1789
- name: `${errorCode}`,
1790
- message: parsedBody.message || parsedBody.Message || errorCode,
1671
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
1672
+ name: parsedBody.code || parsedBody.Code || errorCode,
1791
1673
  $fault: "client",
1792
1674
  $metadata: deserializeMetadata(output),
1793
- };
1675
+ });
1676
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1794
1677
  }
1795
- const message = response.message || response.Message || errorCode;
1796
- response.message = message;
1797
- delete response.Message;
1798
- return Promise.reject(Object.assign(new Error(message), response));
1799
1678
  };
1800
1679
  const deserializeAws_restJson1CreateChannelCommand = async (output, context) => {
1801
1680
  if (output.statusCode !== 201 && output.statusCode >= 300) {
@@ -1823,83 +1702,37 @@ const deserializeAws_restJson1CreateChannelCommandError = async (output, context
1823
1702
  switch (errorCode) {
1824
1703
  case "BadRequestException":
1825
1704
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
1826
- response = {
1827
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
1828
- name: errorCode,
1829
- $metadata: deserializeMetadata(output),
1830
- };
1831
- break;
1705
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
1832
1706
  case "ConflictException":
1833
1707
  case "com.amazonaws.chimesdkmessaging#ConflictException":
1834
- response = {
1835
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
1836
- name: errorCode,
1837
- $metadata: deserializeMetadata(output),
1838
- };
1839
- break;
1708
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
1840
1709
  case "ForbiddenException":
1841
1710
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
1842
- response = {
1843
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
1844
- name: errorCode,
1845
- $metadata: deserializeMetadata(output),
1846
- };
1847
- break;
1711
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
1848
1712
  case "ResourceLimitExceededException":
1849
1713
  case "com.amazonaws.chimesdkmessaging#ResourceLimitExceededException":
1850
- response = {
1851
- ...(await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context)),
1852
- name: errorCode,
1853
- $metadata: deserializeMetadata(output),
1854
- };
1855
- break;
1714
+ throw await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context);
1856
1715
  case "ServiceFailureException":
1857
1716
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
1858
- response = {
1859
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
1860
- name: errorCode,
1861
- $metadata: deserializeMetadata(output),
1862
- };
1863
- break;
1717
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
1864
1718
  case "ServiceUnavailableException":
1865
1719
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
1866
- response = {
1867
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
1868
- name: errorCode,
1869
- $metadata: deserializeMetadata(output),
1870
- };
1871
- break;
1720
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
1872
1721
  case "ThrottledClientException":
1873
1722
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
1874
- response = {
1875
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
1876
- name: errorCode,
1877
- $metadata: deserializeMetadata(output),
1878
- };
1879
- break;
1723
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
1880
1724
  case "UnauthorizedClientException":
1881
1725
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
1882
- response = {
1883
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
1884
- name: errorCode,
1885
- $metadata: deserializeMetadata(output),
1886
- };
1887
- break;
1726
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
1888
1727
  default:
1889
1728
  const parsedBody = parsedOutput.body;
1890
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1891
- response = {
1892
- ...parsedBody,
1893
- name: `${errorCode}`,
1894
- message: parsedBody.message || parsedBody.Message || errorCode,
1729
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
1730
+ name: parsedBody.code || parsedBody.Code || errorCode,
1895
1731
  $fault: "client",
1896
1732
  $metadata: deserializeMetadata(output),
1897
- };
1733
+ });
1734
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1898
1735
  }
1899
- const message = response.message || response.Message || errorCode;
1900
- response.message = message;
1901
- delete response.Message;
1902
- return Promise.reject(Object.assign(new Error(message), response));
1903
1736
  };
1904
1737
  const deserializeAws_restJson1CreateChannelBanCommand = async (output, context) => {
1905
1738
  if (output.statusCode !== 201 && output.statusCode >= 300) {
@@ -1931,83 +1764,37 @@ const deserializeAws_restJson1CreateChannelBanCommandError = async (output, cont
1931
1764
  switch (errorCode) {
1932
1765
  case "BadRequestException":
1933
1766
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
1934
- response = {
1935
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
1936
- name: errorCode,
1937
- $metadata: deserializeMetadata(output),
1938
- };
1939
- break;
1767
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
1940
1768
  case "ConflictException":
1941
1769
  case "com.amazonaws.chimesdkmessaging#ConflictException":
1942
- response = {
1943
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
1944
- name: errorCode,
1945
- $metadata: deserializeMetadata(output),
1946
- };
1947
- break;
1770
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
1948
1771
  case "ForbiddenException":
1949
1772
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
1950
- response = {
1951
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
1952
- name: errorCode,
1953
- $metadata: deserializeMetadata(output),
1954
- };
1955
- break;
1773
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
1956
1774
  case "ResourceLimitExceededException":
1957
1775
  case "com.amazonaws.chimesdkmessaging#ResourceLimitExceededException":
1958
- response = {
1959
- ...(await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context)),
1960
- name: errorCode,
1961
- $metadata: deserializeMetadata(output),
1962
- };
1963
- break;
1776
+ throw await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context);
1964
1777
  case "ServiceFailureException":
1965
1778
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
1966
- response = {
1967
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
1968
- name: errorCode,
1969
- $metadata: deserializeMetadata(output),
1970
- };
1971
- break;
1779
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
1972
1780
  case "ServiceUnavailableException":
1973
1781
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
1974
- response = {
1975
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
1976
- name: errorCode,
1977
- $metadata: deserializeMetadata(output),
1978
- };
1979
- break;
1782
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
1980
1783
  case "ThrottledClientException":
1981
1784
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
1982
- response = {
1983
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
1984
- name: errorCode,
1985
- $metadata: deserializeMetadata(output),
1986
- };
1987
- break;
1785
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
1988
1786
  case "UnauthorizedClientException":
1989
1787
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
1990
- response = {
1991
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
1992
- name: errorCode,
1993
- $metadata: deserializeMetadata(output),
1994
- };
1995
- break;
1788
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
1996
1789
  default:
1997
1790
  const parsedBody = parsedOutput.body;
1998
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1999
- response = {
2000
- ...parsedBody,
2001
- name: `${errorCode}`,
2002
- message: parsedBody.message || parsedBody.Message || errorCode,
1791
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
1792
+ name: parsedBody.code || parsedBody.Code || errorCode,
2003
1793
  $fault: "client",
2004
1794
  $metadata: deserializeMetadata(output),
2005
- };
1795
+ });
1796
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2006
1797
  }
2007
- const message = response.message || response.Message || errorCode;
2008
- response.message = message;
2009
- delete response.Message;
2010
- return Promise.reject(Object.assign(new Error(message), response));
2011
1798
  };
2012
1799
  const deserializeAws_restJson1CreateChannelFlowCommand = async (output, context) => {
2013
1800
  if (output.statusCode !== 201 && output.statusCode >= 300) {
@@ -2035,83 +1822,37 @@ const deserializeAws_restJson1CreateChannelFlowCommandError = async (output, con
2035
1822
  switch (errorCode) {
2036
1823
  case "BadRequestException":
2037
1824
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
2038
- response = {
2039
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
2040
- name: errorCode,
2041
- $metadata: deserializeMetadata(output),
2042
- };
2043
- break;
1825
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
2044
1826
  case "ConflictException":
2045
1827
  case "com.amazonaws.chimesdkmessaging#ConflictException":
2046
- response = {
2047
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
2048
- name: errorCode,
2049
- $metadata: deserializeMetadata(output),
2050
- };
2051
- break;
1828
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
2052
1829
  case "ForbiddenException":
2053
1830
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
2054
- response = {
2055
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
2056
- name: errorCode,
2057
- $metadata: deserializeMetadata(output),
2058
- };
2059
- break;
1831
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
2060
1832
  case "ResourceLimitExceededException":
2061
1833
  case "com.amazonaws.chimesdkmessaging#ResourceLimitExceededException":
2062
- response = {
2063
- ...(await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context)),
2064
- name: errorCode,
2065
- $metadata: deserializeMetadata(output),
2066
- };
2067
- break;
1834
+ throw await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context);
2068
1835
  case "ServiceFailureException":
2069
1836
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
2070
- response = {
2071
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
2072
- name: errorCode,
2073
- $metadata: deserializeMetadata(output),
2074
- };
2075
- break;
1837
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
2076
1838
  case "ServiceUnavailableException":
2077
1839
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
2078
- response = {
2079
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
2080
- name: errorCode,
2081
- $metadata: deserializeMetadata(output),
2082
- };
2083
- break;
1840
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
2084
1841
  case "ThrottledClientException":
2085
1842
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
2086
- response = {
2087
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
2088
- name: errorCode,
2089
- $metadata: deserializeMetadata(output),
2090
- };
2091
- break;
1843
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
2092
1844
  case "UnauthorizedClientException":
2093
1845
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
2094
- response = {
2095
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
2096
- name: errorCode,
2097
- $metadata: deserializeMetadata(output),
2098
- };
2099
- break;
1846
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
2100
1847
  default:
2101
1848
  const parsedBody = parsedOutput.body;
2102
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2103
- response = {
2104
- ...parsedBody,
2105
- name: `${errorCode}`,
2106
- message: parsedBody.message || parsedBody.Message || errorCode,
1849
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
1850
+ name: parsedBody.code || parsedBody.Code || errorCode,
2107
1851
  $fault: "client",
2108
1852
  $metadata: deserializeMetadata(output),
2109
- };
1853
+ });
1854
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2110
1855
  }
2111
- const message = response.message || response.Message || errorCode;
2112
- response.message = message;
2113
- delete response.Message;
2114
- return Promise.reject(Object.assign(new Error(message), response));
2115
1856
  };
2116
1857
  const deserializeAws_restJson1CreateChannelMembershipCommand = async (output, context) => {
2117
1858
  if (output.statusCode !== 201 && output.statusCode >= 300) {
@@ -2143,83 +1884,37 @@ const deserializeAws_restJson1CreateChannelMembershipCommandError = async (outpu
2143
1884
  switch (errorCode) {
2144
1885
  case "BadRequestException":
2145
1886
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
2146
- response = {
2147
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
2148
- name: errorCode,
2149
- $metadata: deserializeMetadata(output),
2150
- };
2151
- break;
1887
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
2152
1888
  case "ConflictException":
2153
1889
  case "com.amazonaws.chimesdkmessaging#ConflictException":
2154
- response = {
2155
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
2156
- name: errorCode,
2157
- $metadata: deserializeMetadata(output),
2158
- };
2159
- break;
1890
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
2160
1891
  case "ForbiddenException":
2161
1892
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
2162
- response = {
2163
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
2164
- name: errorCode,
2165
- $metadata: deserializeMetadata(output),
2166
- };
2167
- break;
1893
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
2168
1894
  case "ResourceLimitExceededException":
2169
1895
  case "com.amazonaws.chimesdkmessaging#ResourceLimitExceededException":
2170
- response = {
2171
- ...(await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context)),
2172
- name: errorCode,
2173
- $metadata: deserializeMetadata(output),
2174
- };
2175
- break;
1896
+ throw await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context);
2176
1897
  case "ServiceFailureException":
2177
1898
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
2178
- response = {
2179
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
2180
- name: errorCode,
2181
- $metadata: deserializeMetadata(output),
2182
- };
2183
- break;
1899
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
2184
1900
  case "ServiceUnavailableException":
2185
1901
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
2186
- response = {
2187
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
2188
- name: errorCode,
2189
- $metadata: deserializeMetadata(output),
2190
- };
2191
- break;
1902
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
2192
1903
  case "ThrottledClientException":
2193
1904
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
2194
- response = {
2195
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
2196
- name: errorCode,
2197
- $metadata: deserializeMetadata(output),
2198
- };
2199
- break;
1905
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
2200
1906
  case "UnauthorizedClientException":
2201
1907
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
2202
- response = {
2203
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
2204
- name: errorCode,
2205
- $metadata: deserializeMetadata(output),
2206
- };
2207
- break;
1908
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
2208
1909
  default:
2209
1910
  const parsedBody = parsedOutput.body;
2210
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2211
- response = {
2212
- ...parsedBody,
2213
- name: `${errorCode}`,
2214
- message: parsedBody.message || parsedBody.Message || errorCode,
1911
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
1912
+ name: parsedBody.code || parsedBody.Code || errorCode,
2215
1913
  $fault: "client",
2216
1914
  $metadata: deserializeMetadata(output),
2217
- };
1915
+ });
1916
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2218
1917
  }
2219
- const message = response.message || response.Message || errorCode;
2220
- response.message = message;
2221
- delete response.Message;
2222
- return Promise.reject(Object.assign(new Error(message), response));
2223
1918
  };
2224
1919
  const deserializeAws_restJson1CreateChannelModeratorCommand = async (output, context) => {
2225
1920
  if (output.statusCode !== 201 && output.statusCode >= 300) {
@@ -2251,83 +1946,37 @@ const deserializeAws_restJson1CreateChannelModeratorCommandError = async (output
2251
1946
  switch (errorCode) {
2252
1947
  case "BadRequestException":
2253
1948
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
2254
- response = {
2255
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
2256
- name: errorCode,
2257
- $metadata: deserializeMetadata(output),
2258
- };
2259
- break;
1949
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
2260
1950
  case "ConflictException":
2261
1951
  case "com.amazonaws.chimesdkmessaging#ConflictException":
2262
- response = {
2263
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
2264
- name: errorCode,
2265
- $metadata: deserializeMetadata(output),
2266
- };
2267
- break;
1952
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
2268
1953
  case "ForbiddenException":
2269
1954
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
2270
- response = {
2271
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
2272
- name: errorCode,
2273
- $metadata: deserializeMetadata(output),
2274
- };
2275
- break;
1955
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
2276
1956
  case "ResourceLimitExceededException":
2277
1957
  case "com.amazonaws.chimesdkmessaging#ResourceLimitExceededException":
2278
- response = {
2279
- ...(await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context)),
2280
- name: errorCode,
2281
- $metadata: deserializeMetadata(output),
2282
- };
2283
- break;
1958
+ throw await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context);
2284
1959
  case "ServiceFailureException":
2285
1960
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
2286
- response = {
2287
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
2288
- name: errorCode,
2289
- $metadata: deserializeMetadata(output),
2290
- };
2291
- break;
1961
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
2292
1962
  case "ServiceUnavailableException":
2293
1963
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
2294
- response = {
2295
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
2296
- name: errorCode,
2297
- $metadata: deserializeMetadata(output),
2298
- };
2299
- break;
1964
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
2300
1965
  case "ThrottledClientException":
2301
1966
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
2302
- response = {
2303
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
2304
- name: errorCode,
2305
- $metadata: deserializeMetadata(output),
2306
- };
2307
- break;
1967
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
2308
1968
  case "UnauthorizedClientException":
2309
1969
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
2310
- response = {
2311
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
2312
- name: errorCode,
2313
- $metadata: deserializeMetadata(output),
2314
- };
2315
- break;
1970
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
2316
1971
  default:
2317
1972
  const parsedBody = parsedOutput.body;
2318
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2319
- response = {
2320
- ...parsedBody,
2321
- name: `${errorCode}`,
2322
- message: parsedBody.message || parsedBody.Message || errorCode,
1973
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
1974
+ name: parsedBody.code || parsedBody.Code || errorCode,
2323
1975
  $fault: "client",
2324
1976
  $metadata: deserializeMetadata(output),
2325
- };
1977
+ });
1978
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2326
1979
  }
2327
- const message = response.message || response.Message || errorCode;
2328
- response.message = message;
2329
- delete response.Message;
2330
- return Promise.reject(Object.assign(new Error(message), response));
2331
1980
  };
2332
1981
  const deserializeAws_restJson1DeleteChannelCommand = async (output, context) => {
2333
1982
  if (output.statusCode !== 204 && output.statusCode >= 300) {
@@ -2351,67 +2000,31 @@ const deserializeAws_restJson1DeleteChannelCommandError = async (output, context
2351
2000
  switch (errorCode) {
2352
2001
  case "BadRequestException":
2353
2002
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
2354
- response = {
2355
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
2356
- name: errorCode,
2357
- $metadata: deserializeMetadata(output),
2358
- };
2359
- break;
2003
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
2360
2004
  case "ForbiddenException":
2361
2005
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
2362
- response = {
2363
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
2364
- name: errorCode,
2365
- $metadata: deserializeMetadata(output),
2366
- };
2367
- break;
2006
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
2368
2007
  case "ServiceFailureException":
2369
2008
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
2370
- response = {
2371
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
2372
- name: errorCode,
2373
- $metadata: deserializeMetadata(output),
2374
- };
2375
- break;
2009
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
2376
2010
  case "ServiceUnavailableException":
2377
2011
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
2378
- response = {
2379
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
2380
- name: errorCode,
2381
- $metadata: deserializeMetadata(output),
2382
- };
2383
- break;
2012
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
2384
2013
  case "ThrottledClientException":
2385
2014
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
2386
- response = {
2387
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
2388
- name: errorCode,
2389
- $metadata: deserializeMetadata(output),
2390
- };
2391
- break;
2015
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
2392
2016
  case "UnauthorizedClientException":
2393
2017
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
2394
- response = {
2395
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
2396
- name: errorCode,
2397
- $metadata: deserializeMetadata(output),
2398
- };
2399
- break;
2018
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
2400
2019
  default:
2401
2020
  const parsedBody = parsedOutput.body;
2402
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2403
- response = {
2404
- ...parsedBody,
2405
- name: `${errorCode}`,
2406
- message: parsedBody.message || parsedBody.Message || errorCode,
2021
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2022
+ name: parsedBody.code || parsedBody.Code || errorCode,
2407
2023
  $fault: "client",
2408
2024
  $metadata: deserializeMetadata(output),
2409
- };
2025
+ });
2026
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2410
2027
  }
2411
- const message = response.message || response.Message || errorCode;
2412
- response.message = message;
2413
- delete response.Message;
2414
- return Promise.reject(Object.assign(new Error(message), response));
2415
2028
  };
2416
2029
  const deserializeAws_restJson1DeleteChannelBanCommand = async (output, context) => {
2417
2030
  if (output.statusCode !== 204 && output.statusCode >= 300) {
@@ -2435,67 +2048,31 @@ const deserializeAws_restJson1DeleteChannelBanCommandError = async (output, cont
2435
2048
  switch (errorCode) {
2436
2049
  case "BadRequestException":
2437
2050
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
2438
- response = {
2439
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
2440
- name: errorCode,
2441
- $metadata: deserializeMetadata(output),
2442
- };
2443
- break;
2051
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
2444
2052
  case "ForbiddenException":
2445
2053
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
2446
- response = {
2447
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
2448
- name: errorCode,
2449
- $metadata: deserializeMetadata(output),
2450
- };
2451
- break;
2054
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
2452
2055
  case "ServiceFailureException":
2453
2056
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
2454
- response = {
2455
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
2456
- name: errorCode,
2457
- $metadata: deserializeMetadata(output),
2458
- };
2459
- break;
2057
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
2460
2058
  case "ServiceUnavailableException":
2461
2059
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
2462
- response = {
2463
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
2464
- name: errorCode,
2465
- $metadata: deserializeMetadata(output),
2466
- };
2467
- break;
2060
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
2468
2061
  case "ThrottledClientException":
2469
2062
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
2470
- response = {
2471
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
2472
- name: errorCode,
2473
- $metadata: deserializeMetadata(output),
2474
- };
2475
- break;
2063
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
2476
2064
  case "UnauthorizedClientException":
2477
2065
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
2478
- response = {
2479
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
2480
- name: errorCode,
2481
- $metadata: deserializeMetadata(output),
2482
- };
2483
- break;
2066
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
2484
2067
  default:
2485
2068
  const parsedBody = parsedOutput.body;
2486
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2487
- response = {
2488
- ...parsedBody,
2489
- name: `${errorCode}`,
2490
- message: parsedBody.message || parsedBody.Message || errorCode,
2069
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2070
+ name: parsedBody.code || parsedBody.Code || errorCode,
2491
2071
  $fault: "client",
2492
2072
  $metadata: deserializeMetadata(output),
2493
- };
2073
+ });
2074
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2494
2075
  }
2495
- const message = response.message || response.Message || errorCode;
2496
- response.message = message;
2497
- delete response.Message;
2498
- return Promise.reject(Object.assign(new Error(message), response));
2499
2076
  };
2500
2077
  const deserializeAws_restJson1DeleteChannelFlowCommand = async (output, context) => {
2501
2078
  if (output.statusCode !== 204 && output.statusCode >= 300) {
@@ -2519,75 +2096,34 @@ const deserializeAws_restJson1DeleteChannelFlowCommandError = async (output, con
2519
2096
  switch (errorCode) {
2520
2097
  case "BadRequestException":
2521
2098
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
2522
- response = {
2523
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
2524
- name: errorCode,
2525
- $metadata: deserializeMetadata(output),
2526
- };
2527
- break;
2099
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
2528
2100
  case "ConflictException":
2529
2101
  case "com.amazonaws.chimesdkmessaging#ConflictException":
2530
- response = {
2531
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
2532
- name: errorCode,
2533
- $metadata: deserializeMetadata(output),
2534
- };
2535
- break;
2102
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
2536
2103
  case "ForbiddenException":
2537
2104
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
2538
- response = {
2539
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
2540
- name: errorCode,
2541
- $metadata: deserializeMetadata(output),
2542
- };
2543
- break;
2105
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
2544
2106
  case "ServiceFailureException":
2545
2107
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
2546
- response = {
2547
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
2548
- name: errorCode,
2549
- $metadata: deserializeMetadata(output),
2550
- };
2551
- break;
2108
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
2552
2109
  case "ServiceUnavailableException":
2553
2110
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
2554
- response = {
2555
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
2556
- name: errorCode,
2557
- $metadata: deserializeMetadata(output),
2558
- };
2559
- break;
2111
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
2560
2112
  case "ThrottledClientException":
2561
2113
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
2562
- response = {
2563
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
2564
- name: errorCode,
2565
- $metadata: deserializeMetadata(output),
2566
- };
2567
- break;
2114
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
2568
2115
  case "UnauthorizedClientException":
2569
2116
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
2570
- response = {
2571
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
2572
- name: errorCode,
2573
- $metadata: deserializeMetadata(output),
2574
- };
2575
- break;
2117
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
2576
2118
  default:
2577
2119
  const parsedBody = parsedOutput.body;
2578
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2579
- response = {
2580
- ...parsedBody,
2581
- name: `${errorCode}`,
2582
- message: parsedBody.message || parsedBody.Message || errorCode,
2120
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2121
+ name: parsedBody.code || parsedBody.Code || errorCode,
2583
2122
  $fault: "client",
2584
2123
  $metadata: deserializeMetadata(output),
2585
- };
2124
+ });
2125
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2586
2126
  }
2587
- const message = response.message || response.Message || errorCode;
2588
- response.message = message;
2589
- delete response.Message;
2590
- return Promise.reject(Object.assign(new Error(message), response));
2591
2127
  };
2592
2128
  const deserializeAws_restJson1DeleteChannelMembershipCommand = async (output, context) => {
2593
2129
  if (output.statusCode !== 204 && output.statusCode >= 300) {
@@ -2611,75 +2147,34 @@ const deserializeAws_restJson1DeleteChannelMembershipCommandError = async (outpu
2611
2147
  switch (errorCode) {
2612
2148
  case "BadRequestException":
2613
2149
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
2614
- response = {
2615
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
2616
- name: errorCode,
2617
- $metadata: deserializeMetadata(output),
2618
- };
2619
- break;
2150
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
2620
2151
  case "ConflictException":
2621
2152
  case "com.amazonaws.chimesdkmessaging#ConflictException":
2622
- response = {
2623
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
2624
- name: errorCode,
2625
- $metadata: deserializeMetadata(output),
2626
- };
2627
- break;
2153
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
2628
2154
  case "ForbiddenException":
2629
2155
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
2630
- response = {
2631
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
2632
- name: errorCode,
2633
- $metadata: deserializeMetadata(output),
2634
- };
2635
- break;
2156
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
2636
2157
  case "ServiceFailureException":
2637
2158
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
2638
- response = {
2639
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
2640
- name: errorCode,
2641
- $metadata: deserializeMetadata(output),
2642
- };
2643
- break;
2159
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
2644
2160
  case "ServiceUnavailableException":
2645
2161
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
2646
- response = {
2647
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
2648
- name: errorCode,
2649
- $metadata: deserializeMetadata(output),
2650
- };
2651
- break;
2162
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
2652
2163
  case "ThrottledClientException":
2653
2164
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
2654
- response = {
2655
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
2656
- name: errorCode,
2657
- $metadata: deserializeMetadata(output),
2658
- };
2659
- break;
2165
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
2660
2166
  case "UnauthorizedClientException":
2661
2167
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
2662
- response = {
2663
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
2664
- name: errorCode,
2665
- $metadata: deserializeMetadata(output),
2666
- };
2667
- break;
2168
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
2668
2169
  default:
2669
2170
  const parsedBody = parsedOutput.body;
2670
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2671
- response = {
2672
- ...parsedBody,
2673
- name: `${errorCode}`,
2674
- message: parsedBody.message || parsedBody.Message || errorCode,
2171
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2172
+ name: parsedBody.code || parsedBody.Code || errorCode,
2675
2173
  $fault: "client",
2676
2174
  $metadata: deserializeMetadata(output),
2677
- };
2175
+ });
2176
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2678
2177
  }
2679
- const message = response.message || response.Message || errorCode;
2680
- response.message = message;
2681
- delete response.Message;
2682
- return Promise.reject(Object.assign(new Error(message), response));
2683
2178
  };
2684
2179
  const deserializeAws_restJson1DeleteChannelMessageCommand = async (output, context) => {
2685
2180
  if (output.statusCode !== 204 && output.statusCode >= 300) {
@@ -2703,67 +2198,31 @@ const deserializeAws_restJson1DeleteChannelMessageCommandError = async (output,
2703
2198
  switch (errorCode) {
2704
2199
  case "BadRequestException":
2705
2200
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
2706
- response = {
2707
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
2708
- name: errorCode,
2709
- $metadata: deserializeMetadata(output),
2710
- };
2711
- break;
2201
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
2712
2202
  case "ForbiddenException":
2713
2203
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
2714
- response = {
2715
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
2716
- name: errorCode,
2717
- $metadata: deserializeMetadata(output),
2718
- };
2719
- break;
2204
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
2720
2205
  case "ServiceFailureException":
2721
2206
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
2722
- response = {
2723
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
2724
- name: errorCode,
2725
- $metadata: deserializeMetadata(output),
2726
- };
2727
- break;
2207
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
2728
2208
  case "ServiceUnavailableException":
2729
2209
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
2730
- response = {
2731
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
2732
- name: errorCode,
2733
- $metadata: deserializeMetadata(output),
2734
- };
2735
- break;
2210
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
2736
2211
  case "ThrottledClientException":
2737
2212
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
2738
- response = {
2739
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
2740
- name: errorCode,
2741
- $metadata: deserializeMetadata(output),
2742
- };
2743
- break;
2213
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
2744
2214
  case "UnauthorizedClientException":
2745
2215
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
2746
- response = {
2747
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
2748
- name: errorCode,
2749
- $metadata: deserializeMetadata(output),
2750
- };
2751
- break;
2216
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
2752
2217
  default:
2753
2218
  const parsedBody = parsedOutput.body;
2754
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2755
- response = {
2756
- ...parsedBody,
2757
- name: `${errorCode}`,
2758
- message: parsedBody.message || parsedBody.Message || errorCode,
2219
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2220
+ name: parsedBody.code || parsedBody.Code || errorCode,
2759
2221
  $fault: "client",
2760
2222
  $metadata: deserializeMetadata(output),
2761
- };
2223
+ });
2224
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2762
2225
  }
2763
- const message = response.message || response.Message || errorCode;
2764
- response.message = message;
2765
- delete response.Message;
2766
- return Promise.reject(Object.assign(new Error(message), response));
2767
2226
  };
2768
2227
  const deserializeAws_restJson1DeleteChannelModeratorCommand = async (output, context) => {
2769
2228
  if (output.statusCode !== 204 && output.statusCode >= 300) {
@@ -2787,67 +2246,31 @@ const deserializeAws_restJson1DeleteChannelModeratorCommandError = async (output
2787
2246
  switch (errorCode) {
2788
2247
  case "BadRequestException":
2789
2248
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
2790
- response = {
2791
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
2792
- name: errorCode,
2793
- $metadata: deserializeMetadata(output),
2794
- };
2795
- break;
2249
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
2796
2250
  case "ForbiddenException":
2797
2251
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
2798
- response = {
2799
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
2800
- name: errorCode,
2801
- $metadata: deserializeMetadata(output),
2802
- };
2803
- break;
2252
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
2804
2253
  case "ServiceFailureException":
2805
2254
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
2806
- response = {
2807
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
2808
- name: errorCode,
2809
- $metadata: deserializeMetadata(output),
2810
- };
2811
- break;
2255
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
2812
2256
  case "ServiceUnavailableException":
2813
2257
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
2814
- response = {
2815
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
2816
- name: errorCode,
2817
- $metadata: deserializeMetadata(output),
2818
- };
2819
- break;
2258
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
2820
2259
  case "ThrottledClientException":
2821
2260
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
2822
- response = {
2823
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
2824
- name: errorCode,
2825
- $metadata: deserializeMetadata(output),
2826
- };
2827
- break;
2261
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
2828
2262
  case "UnauthorizedClientException":
2829
2263
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
2830
- response = {
2831
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
2832
- name: errorCode,
2833
- $metadata: deserializeMetadata(output),
2834
- };
2835
- break;
2264
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
2836
2265
  default:
2837
2266
  const parsedBody = parsedOutput.body;
2838
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2839
- response = {
2840
- ...parsedBody,
2841
- name: `${errorCode}`,
2842
- message: parsedBody.message || parsedBody.Message || errorCode,
2267
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2268
+ name: parsedBody.code || parsedBody.Code || errorCode,
2843
2269
  $fault: "client",
2844
2270
  $metadata: deserializeMetadata(output),
2845
- };
2271
+ });
2272
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2846
2273
  }
2847
- const message = response.message || response.Message || errorCode;
2848
- response.message = message;
2849
- delete response.Message;
2850
- return Promise.reject(Object.assign(new Error(message), response));
2851
2274
  };
2852
2275
  const deserializeAws_restJson1DescribeChannelCommand = async (output, context) => {
2853
2276
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -2875,67 +2298,31 @@ const deserializeAws_restJson1DescribeChannelCommandError = async (output, conte
2875
2298
  switch (errorCode) {
2876
2299
  case "BadRequestException":
2877
2300
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
2878
- response = {
2879
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
2880
- name: errorCode,
2881
- $metadata: deserializeMetadata(output),
2882
- };
2883
- break;
2301
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
2884
2302
  case "ForbiddenException":
2885
2303
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
2886
- response = {
2887
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
2888
- name: errorCode,
2889
- $metadata: deserializeMetadata(output),
2890
- };
2891
- break;
2304
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
2892
2305
  case "ServiceFailureException":
2893
2306
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
2894
- response = {
2895
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
2896
- name: errorCode,
2897
- $metadata: deserializeMetadata(output),
2898
- };
2899
- break;
2307
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
2900
2308
  case "ServiceUnavailableException":
2901
2309
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
2902
- response = {
2903
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
2904
- name: errorCode,
2905
- $metadata: deserializeMetadata(output),
2906
- };
2907
- break;
2310
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
2908
2311
  case "ThrottledClientException":
2909
2312
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
2910
- response = {
2911
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
2912
- name: errorCode,
2913
- $metadata: deserializeMetadata(output),
2914
- };
2915
- break;
2313
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
2916
2314
  case "UnauthorizedClientException":
2917
2315
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
2918
- response = {
2919
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
2920
- name: errorCode,
2921
- $metadata: deserializeMetadata(output),
2922
- };
2923
- break;
2316
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
2924
2317
  default:
2925
2318
  const parsedBody = parsedOutput.body;
2926
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2927
- response = {
2928
- ...parsedBody,
2929
- name: `${errorCode}`,
2930
- message: parsedBody.message || parsedBody.Message || errorCode,
2319
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2320
+ name: parsedBody.code || parsedBody.Code || errorCode,
2931
2321
  $fault: "client",
2932
2322
  $metadata: deserializeMetadata(output),
2933
- };
2323
+ });
2324
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2934
2325
  }
2935
- const message = response.message || response.Message || errorCode;
2936
- response.message = message;
2937
- delete response.Message;
2938
- return Promise.reject(Object.assign(new Error(message), response));
2939
2326
  };
2940
2327
  const deserializeAws_restJson1DescribeChannelBanCommand = async (output, context) => {
2941
2328
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -2963,75 +2350,34 @@ const deserializeAws_restJson1DescribeChannelBanCommandError = async (output, co
2963
2350
  switch (errorCode) {
2964
2351
  case "BadRequestException":
2965
2352
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
2966
- response = {
2967
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
2968
- name: errorCode,
2969
- $metadata: deserializeMetadata(output),
2970
- };
2971
- break;
2353
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
2972
2354
  case "ForbiddenException":
2973
2355
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
2974
- response = {
2975
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
2976
- name: errorCode,
2977
- $metadata: deserializeMetadata(output),
2978
- };
2979
- break;
2356
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
2980
2357
  case "NotFoundException":
2981
2358
  case "com.amazonaws.chimesdkmessaging#NotFoundException":
2982
- response = {
2983
- ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
2984
- name: errorCode,
2985
- $metadata: deserializeMetadata(output),
2986
- };
2987
- break;
2359
+ throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
2988
2360
  case "ServiceFailureException":
2989
2361
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
2990
- response = {
2991
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
2992
- name: errorCode,
2993
- $metadata: deserializeMetadata(output),
2994
- };
2995
- break;
2362
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
2996
2363
  case "ServiceUnavailableException":
2997
2364
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
2998
- response = {
2999
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
3000
- name: errorCode,
3001
- $metadata: deserializeMetadata(output),
3002
- };
3003
- break;
2365
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
3004
2366
  case "ThrottledClientException":
3005
2367
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
3006
- response = {
3007
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
3008
- name: errorCode,
3009
- $metadata: deserializeMetadata(output),
3010
- };
3011
- break;
2368
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
3012
2369
  case "UnauthorizedClientException":
3013
2370
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
3014
- response = {
3015
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
3016
- name: errorCode,
3017
- $metadata: deserializeMetadata(output),
3018
- };
3019
- break;
2371
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
3020
2372
  default:
3021
2373
  const parsedBody = parsedOutput.body;
3022
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3023
- response = {
3024
- ...parsedBody,
3025
- name: `${errorCode}`,
3026
- message: parsedBody.message || parsedBody.Message || errorCode,
2374
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2375
+ name: parsedBody.code || parsedBody.Code || errorCode,
3027
2376
  $fault: "client",
3028
2377
  $metadata: deserializeMetadata(output),
3029
- };
2378
+ });
2379
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3030
2380
  }
3031
- const message = response.message || response.Message || errorCode;
3032
- response.message = message;
3033
- delete response.Message;
3034
- return Promise.reject(Object.assign(new Error(message), response));
3035
2381
  };
3036
2382
  const deserializeAws_restJson1DescribeChannelFlowCommand = async (output, context) => {
3037
2383
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -3059,67 +2405,31 @@ const deserializeAws_restJson1DescribeChannelFlowCommandError = async (output, c
3059
2405
  switch (errorCode) {
3060
2406
  case "BadRequestException":
3061
2407
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
3062
- response = {
3063
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
3064
- name: errorCode,
3065
- $metadata: deserializeMetadata(output),
3066
- };
3067
- break;
2408
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
3068
2409
  case "ForbiddenException":
3069
2410
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
3070
- response = {
3071
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
3072
- name: errorCode,
3073
- $metadata: deserializeMetadata(output),
3074
- };
3075
- break;
2411
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
3076
2412
  case "ServiceFailureException":
3077
2413
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
3078
- response = {
3079
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
3080
- name: errorCode,
3081
- $metadata: deserializeMetadata(output),
3082
- };
3083
- break;
2414
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
3084
2415
  case "ServiceUnavailableException":
3085
2416
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
3086
- response = {
3087
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
3088
- name: errorCode,
3089
- $metadata: deserializeMetadata(output),
3090
- };
3091
- break;
2417
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
3092
2418
  case "ThrottledClientException":
3093
2419
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
3094
- response = {
3095
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
3096
- name: errorCode,
3097
- $metadata: deserializeMetadata(output),
3098
- };
3099
- break;
2420
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
3100
2421
  case "UnauthorizedClientException":
3101
2422
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
3102
- response = {
3103
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
3104
- name: errorCode,
3105
- $metadata: deserializeMetadata(output),
3106
- };
3107
- break;
2423
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
3108
2424
  default:
3109
2425
  const parsedBody = parsedOutput.body;
3110
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3111
- response = {
3112
- ...parsedBody,
3113
- name: `${errorCode}`,
3114
- message: parsedBody.message || parsedBody.Message || errorCode,
2426
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2427
+ name: parsedBody.code || parsedBody.Code || errorCode,
3115
2428
  $fault: "client",
3116
2429
  $metadata: deserializeMetadata(output),
3117
- };
2430
+ });
2431
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3118
2432
  }
3119
- const message = response.message || response.Message || errorCode;
3120
- response.message = message;
3121
- delete response.Message;
3122
- return Promise.reject(Object.assign(new Error(message), response));
3123
2433
  };
3124
2434
  const deserializeAws_restJson1DescribeChannelMembershipCommand = async (output, context) => {
3125
2435
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -3147,75 +2457,34 @@ const deserializeAws_restJson1DescribeChannelMembershipCommandError = async (out
3147
2457
  switch (errorCode) {
3148
2458
  case "BadRequestException":
3149
2459
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
3150
- response = {
3151
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
3152
- name: errorCode,
3153
- $metadata: deserializeMetadata(output),
3154
- };
3155
- break;
2460
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
3156
2461
  case "ForbiddenException":
3157
2462
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
3158
- response = {
3159
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
3160
- name: errorCode,
3161
- $metadata: deserializeMetadata(output),
3162
- };
3163
- break;
2463
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
3164
2464
  case "NotFoundException":
3165
2465
  case "com.amazonaws.chimesdkmessaging#NotFoundException":
3166
- response = {
3167
- ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
3168
- name: errorCode,
3169
- $metadata: deserializeMetadata(output),
3170
- };
3171
- break;
2466
+ throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
3172
2467
  case "ServiceFailureException":
3173
2468
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
3174
- response = {
3175
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
3176
- name: errorCode,
3177
- $metadata: deserializeMetadata(output),
3178
- };
3179
- break;
2469
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
3180
2470
  case "ServiceUnavailableException":
3181
2471
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
3182
- response = {
3183
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
3184
- name: errorCode,
3185
- $metadata: deserializeMetadata(output),
3186
- };
3187
- break;
2472
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
3188
2473
  case "ThrottledClientException":
3189
2474
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
3190
- response = {
3191
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
3192
- name: errorCode,
3193
- $metadata: deserializeMetadata(output),
3194
- };
3195
- break;
2475
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
3196
2476
  case "UnauthorizedClientException":
3197
2477
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
3198
- response = {
3199
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
3200
- name: errorCode,
3201
- $metadata: deserializeMetadata(output),
3202
- };
3203
- break;
2478
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
3204
2479
  default:
3205
2480
  const parsedBody = parsedOutput.body;
3206
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3207
- response = {
3208
- ...parsedBody,
3209
- name: `${errorCode}`,
3210
- message: parsedBody.message || parsedBody.Message || errorCode,
2481
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2482
+ name: parsedBody.code || parsedBody.Code || errorCode,
3211
2483
  $fault: "client",
3212
2484
  $metadata: deserializeMetadata(output),
3213
- };
2485
+ });
2486
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3214
2487
  }
3215
- const message = response.message || response.Message || errorCode;
3216
- response.message = message;
3217
- delete response.Message;
3218
- return Promise.reject(Object.assign(new Error(message), response));
3219
2488
  };
3220
2489
  const deserializeAws_restJson1DescribeChannelMembershipForAppInstanceUserCommand = async (output, context) => {
3221
2490
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -3243,67 +2512,31 @@ const deserializeAws_restJson1DescribeChannelMembershipForAppInstanceUserCommand
3243
2512
  switch (errorCode) {
3244
2513
  case "BadRequestException":
3245
2514
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
3246
- response = {
3247
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
3248
- name: errorCode,
3249
- $metadata: deserializeMetadata(output),
3250
- };
3251
- break;
2515
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
3252
2516
  case "ForbiddenException":
3253
2517
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
3254
- response = {
3255
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
3256
- name: errorCode,
3257
- $metadata: deserializeMetadata(output),
3258
- };
3259
- break;
2518
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
3260
2519
  case "ServiceFailureException":
3261
2520
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
3262
- response = {
3263
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
3264
- name: errorCode,
3265
- $metadata: deserializeMetadata(output),
3266
- };
3267
- break;
2521
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
3268
2522
  case "ServiceUnavailableException":
3269
2523
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
3270
- response = {
3271
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
3272
- name: errorCode,
3273
- $metadata: deserializeMetadata(output),
3274
- };
3275
- break;
2524
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
3276
2525
  case "ThrottledClientException":
3277
2526
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
3278
- response = {
3279
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
3280
- name: errorCode,
3281
- $metadata: deserializeMetadata(output),
3282
- };
3283
- break;
2527
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
3284
2528
  case "UnauthorizedClientException":
3285
2529
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
3286
- response = {
3287
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
3288
- name: errorCode,
3289
- $metadata: deserializeMetadata(output),
3290
- };
3291
- break;
2530
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
3292
2531
  default:
3293
2532
  const parsedBody = parsedOutput.body;
3294
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3295
- response = {
3296
- ...parsedBody,
3297
- name: `${errorCode}`,
3298
- message: parsedBody.message || parsedBody.Message || errorCode,
2533
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2534
+ name: parsedBody.code || parsedBody.Code || errorCode,
3299
2535
  $fault: "client",
3300
2536
  $metadata: deserializeMetadata(output),
3301
- };
2537
+ });
2538
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3302
2539
  }
3303
- const message = response.message || response.Message || errorCode;
3304
- response.message = message;
3305
- delete response.Message;
3306
- return Promise.reject(Object.assign(new Error(message), response));
3307
2540
  };
3308
2541
  const deserializeAws_restJson1DescribeChannelModeratedByAppInstanceUserCommand = async (output, context) => {
3309
2542
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -3331,67 +2564,31 @@ const deserializeAws_restJson1DescribeChannelModeratedByAppInstanceUserCommandEr
3331
2564
  switch (errorCode) {
3332
2565
  case "BadRequestException":
3333
2566
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
3334
- response = {
3335
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
3336
- name: errorCode,
3337
- $metadata: deserializeMetadata(output),
3338
- };
3339
- break;
2567
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
3340
2568
  case "ForbiddenException":
3341
2569
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
3342
- response = {
3343
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
3344
- name: errorCode,
3345
- $metadata: deserializeMetadata(output),
3346
- };
3347
- break;
2570
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
3348
2571
  case "ServiceFailureException":
3349
2572
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
3350
- response = {
3351
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
3352
- name: errorCode,
3353
- $metadata: deserializeMetadata(output),
3354
- };
3355
- break;
2573
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
3356
2574
  case "ServiceUnavailableException":
3357
2575
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
3358
- response = {
3359
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
3360
- name: errorCode,
3361
- $metadata: deserializeMetadata(output),
3362
- };
3363
- break;
2576
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
3364
2577
  case "ThrottledClientException":
3365
2578
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
3366
- response = {
3367
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
3368
- name: errorCode,
3369
- $metadata: deserializeMetadata(output),
3370
- };
3371
- break;
2579
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
3372
2580
  case "UnauthorizedClientException":
3373
2581
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
3374
- response = {
3375
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
3376
- name: errorCode,
3377
- $metadata: deserializeMetadata(output),
3378
- };
3379
- break;
2582
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
3380
2583
  default:
3381
2584
  const parsedBody = parsedOutput.body;
3382
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3383
- response = {
3384
- ...parsedBody,
3385
- name: `${errorCode}`,
3386
- message: parsedBody.message || parsedBody.Message || errorCode,
2585
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2586
+ name: parsedBody.code || parsedBody.Code || errorCode,
3387
2587
  $fault: "client",
3388
2588
  $metadata: deserializeMetadata(output),
3389
- };
2589
+ });
2590
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3390
2591
  }
3391
- const message = response.message || response.Message || errorCode;
3392
- response.message = message;
3393
- delete response.Message;
3394
- return Promise.reject(Object.assign(new Error(message), response));
3395
2592
  };
3396
2593
  const deserializeAws_restJson1DescribeChannelModeratorCommand = async (output, context) => {
3397
2594
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -3419,75 +2616,34 @@ const deserializeAws_restJson1DescribeChannelModeratorCommandError = async (outp
3419
2616
  switch (errorCode) {
3420
2617
  case "BadRequestException":
3421
2618
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
3422
- response = {
3423
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
3424
- name: errorCode,
3425
- $metadata: deserializeMetadata(output),
3426
- };
3427
- break;
2619
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
3428
2620
  case "ForbiddenException":
3429
2621
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
3430
- response = {
3431
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
3432
- name: errorCode,
3433
- $metadata: deserializeMetadata(output),
3434
- };
3435
- break;
2622
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
3436
2623
  case "NotFoundException":
3437
2624
  case "com.amazonaws.chimesdkmessaging#NotFoundException":
3438
- response = {
3439
- ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
3440
- name: errorCode,
3441
- $metadata: deserializeMetadata(output),
3442
- };
3443
- break;
2625
+ throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
3444
2626
  case "ServiceFailureException":
3445
2627
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
3446
- response = {
3447
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
3448
- name: errorCode,
3449
- $metadata: deserializeMetadata(output),
3450
- };
3451
- break;
2628
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
3452
2629
  case "ServiceUnavailableException":
3453
2630
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
3454
- response = {
3455
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
3456
- name: errorCode,
3457
- $metadata: deserializeMetadata(output),
3458
- };
3459
- break;
2631
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
3460
2632
  case "ThrottledClientException":
3461
2633
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
3462
- response = {
3463
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
3464
- name: errorCode,
3465
- $metadata: deserializeMetadata(output),
3466
- };
3467
- break;
2634
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
3468
2635
  case "UnauthorizedClientException":
3469
2636
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
3470
- response = {
3471
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
3472
- name: errorCode,
3473
- $metadata: deserializeMetadata(output),
3474
- };
3475
- break;
2637
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
3476
2638
  default:
3477
2639
  const parsedBody = parsedOutput.body;
3478
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3479
- response = {
3480
- ...parsedBody,
3481
- name: `${errorCode}`,
3482
- message: parsedBody.message || parsedBody.Message || errorCode,
2640
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2641
+ name: parsedBody.code || parsedBody.Code || errorCode,
3483
2642
  $fault: "client",
3484
2643
  $metadata: deserializeMetadata(output),
3485
- };
2644
+ });
2645
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3486
2646
  }
3487
- const message = response.message || response.Message || errorCode;
3488
- response.message = message;
3489
- delete response.Message;
3490
- return Promise.reject(Object.assign(new Error(message), response));
3491
2647
  };
3492
2648
  const deserializeAws_restJson1DisassociateChannelFlowCommand = async (output, context) => {
3493
2649
  if (output.statusCode !== 204 && output.statusCode >= 300) {
@@ -3511,83 +2667,37 @@ const deserializeAws_restJson1DisassociateChannelFlowCommandError = async (outpu
3511
2667
  switch (errorCode) {
3512
2668
  case "BadRequestException":
3513
2669
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
3514
- response = {
3515
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
3516
- name: errorCode,
3517
- $metadata: deserializeMetadata(output),
3518
- };
3519
- break;
2670
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
3520
2671
  case "ConflictException":
3521
2672
  case "com.amazonaws.chimesdkmessaging#ConflictException":
3522
- response = {
3523
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
3524
- name: errorCode,
3525
- $metadata: deserializeMetadata(output),
3526
- };
3527
- break;
2673
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
3528
2674
  case "ForbiddenException":
3529
2675
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
3530
- response = {
3531
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
3532
- name: errorCode,
3533
- $metadata: deserializeMetadata(output),
3534
- };
3535
- break;
2676
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
3536
2677
  case "NotFoundException":
3537
2678
  case "com.amazonaws.chimesdkmessaging#NotFoundException":
3538
- response = {
3539
- ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
3540
- name: errorCode,
3541
- $metadata: deserializeMetadata(output),
3542
- };
3543
- break;
2679
+ throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
3544
2680
  case "ServiceFailureException":
3545
2681
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
3546
- response = {
3547
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
3548
- name: errorCode,
3549
- $metadata: deserializeMetadata(output),
3550
- };
3551
- break;
2682
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
3552
2683
  case "ServiceUnavailableException":
3553
2684
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
3554
- response = {
3555
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
3556
- name: errorCode,
3557
- $metadata: deserializeMetadata(output),
3558
- };
3559
- break;
2685
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
3560
2686
  case "ThrottledClientException":
3561
2687
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
3562
- response = {
3563
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
3564
- name: errorCode,
3565
- $metadata: deserializeMetadata(output),
3566
- };
3567
- break;
2688
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
3568
2689
  case "UnauthorizedClientException":
3569
2690
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
3570
- response = {
3571
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
3572
- name: errorCode,
3573
- $metadata: deserializeMetadata(output),
3574
- };
3575
- break;
2691
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
3576
2692
  default:
3577
2693
  const parsedBody = parsedOutput.body;
3578
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3579
- response = {
3580
- ...parsedBody,
3581
- name: `${errorCode}`,
3582
- message: parsedBody.message || parsedBody.Message || errorCode,
2694
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2695
+ name: parsedBody.code || parsedBody.Code || errorCode,
3583
2696
  $fault: "client",
3584
2697
  $metadata: deserializeMetadata(output),
3585
- };
2698
+ });
2699
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3586
2700
  }
3587
- const message = response.message || response.Message || errorCode;
3588
- response.message = message;
3589
- delete response.Message;
3590
- return Promise.reject(Object.assign(new Error(message), response));
3591
2701
  };
3592
2702
  const deserializeAws_restJson1GetChannelMembershipPreferencesCommand = async (output, context) => {
3593
2703
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -3623,67 +2733,31 @@ const deserializeAws_restJson1GetChannelMembershipPreferencesCommandError = asyn
3623
2733
  switch (errorCode) {
3624
2734
  case "BadRequestException":
3625
2735
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
3626
- response = {
3627
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
3628
- name: errorCode,
3629
- $metadata: deserializeMetadata(output),
3630
- };
3631
- break;
2736
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
3632
2737
  case "ForbiddenException":
3633
2738
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
3634
- response = {
3635
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
3636
- name: errorCode,
3637
- $metadata: deserializeMetadata(output),
3638
- };
3639
- break;
2739
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
3640
2740
  case "ServiceFailureException":
3641
2741
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
3642
- response = {
3643
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
3644
- name: errorCode,
3645
- $metadata: deserializeMetadata(output),
3646
- };
3647
- break;
2742
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
3648
2743
  case "ServiceUnavailableException":
3649
2744
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
3650
- response = {
3651
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
3652
- name: errorCode,
3653
- $metadata: deserializeMetadata(output),
3654
- };
3655
- break;
2745
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
3656
2746
  case "ThrottledClientException":
3657
2747
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
3658
- response = {
3659
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
3660
- name: errorCode,
3661
- $metadata: deserializeMetadata(output),
3662
- };
3663
- break;
2748
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
3664
2749
  case "UnauthorizedClientException":
3665
2750
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
3666
- response = {
3667
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
3668
- name: errorCode,
3669
- $metadata: deserializeMetadata(output),
3670
- };
3671
- break;
2751
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
3672
2752
  default:
3673
2753
  const parsedBody = parsedOutput.body;
3674
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3675
- response = {
3676
- ...parsedBody,
3677
- name: `${errorCode}`,
3678
- message: parsedBody.message || parsedBody.Message || errorCode,
2754
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2755
+ name: parsedBody.code || parsedBody.Code || errorCode,
3679
2756
  $fault: "client",
3680
2757
  $metadata: deserializeMetadata(output),
3681
- };
2758
+ });
2759
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3682
2760
  }
3683
- const message = response.message || response.Message || errorCode;
3684
- response.message = message;
3685
- delete response.Message;
3686
- return Promise.reject(Object.assign(new Error(message), response));
3687
2761
  };
3688
2762
  const deserializeAws_restJson1GetChannelMessageCommand = async (output, context) => {
3689
2763
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -3711,75 +2785,34 @@ const deserializeAws_restJson1GetChannelMessageCommandError = async (output, con
3711
2785
  switch (errorCode) {
3712
2786
  case "BadRequestException":
3713
2787
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
3714
- response = {
3715
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
3716
- name: errorCode,
3717
- $metadata: deserializeMetadata(output),
3718
- };
3719
- break;
2788
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
3720
2789
  case "ForbiddenException":
3721
2790
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
3722
- response = {
3723
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
3724
- name: errorCode,
3725
- $metadata: deserializeMetadata(output),
3726
- };
3727
- break;
2791
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
3728
2792
  case "NotFoundException":
3729
2793
  case "com.amazonaws.chimesdkmessaging#NotFoundException":
3730
- response = {
3731
- ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
3732
- name: errorCode,
3733
- $metadata: deserializeMetadata(output),
3734
- };
3735
- break;
2794
+ throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
3736
2795
  case "ServiceFailureException":
3737
2796
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
3738
- response = {
3739
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
3740
- name: errorCode,
3741
- $metadata: deserializeMetadata(output),
3742
- };
3743
- break;
2797
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
3744
2798
  case "ServiceUnavailableException":
3745
2799
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
3746
- response = {
3747
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
3748
- name: errorCode,
3749
- $metadata: deserializeMetadata(output),
3750
- };
3751
- break;
2800
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
3752
2801
  case "ThrottledClientException":
3753
2802
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
3754
- response = {
3755
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
3756
- name: errorCode,
3757
- $metadata: deserializeMetadata(output),
3758
- };
3759
- break;
2803
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
3760
2804
  case "UnauthorizedClientException":
3761
2805
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
3762
- response = {
3763
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
3764
- name: errorCode,
3765
- $metadata: deserializeMetadata(output),
3766
- };
3767
- break;
2806
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
3768
2807
  default:
3769
2808
  const parsedBody = parsedOutput.body;
3770
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3771
- response = {
3772
- ...parsedBody,
3773
- name: `${errorCode}`,
3774
- message: parsedBody.message || parsedBody.Message || errorCode,
2809
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2810
+ name: parsedBody.code || parsedBody.Code || errorCode,
3775
2811
  $fault: "client",
3776
2812
  $metadata: deserializeMetadata(output),
3777
- };
2813
+ });
2814
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3778
2815
  }
3779
- const message = response.message || response.Message || errorCode;
3780
- response.message = message;
3781
- delete response.Message;
3782
- return Promise.reject(Object.assign(new Error(message), response));
3783
2816
  };
3784
2817
  const deserializeAws_restJson1GetChannelMessageStatusCommand = async (output, context) => {
3785
2818
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -3807,67 +2840,31 @@ const deserializeAws_restJson1GetChannelMessageStatusCommandError = async (outpu
3807
2840
  switch (errorCode) {
3808
2841
  case "BadRequestException":
3809
2842
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
3810
- response = {
3811
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
3812
- name: errorCode,
3813
- $metadata: deserializeMetadata(output),
3814
- };
3815
- break;
2843
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
3816
2844
  case "ForbiddenException":
3817
2845
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
3818
- response = {
3819
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
3820
- name: errorCode,
3821
- $metadata: deserializeMetadata(output),
3822
- };
3823
- break;
2846
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
3824
2847
  case "ServiceFailureException":
3825
2848
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
3826
- response = {
3827
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
3828
- name: errorCode,
3829
- $metadata: deserializeMetadata(output),
3830
- };
3831
- break;
2849
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
3832
2850
  case "ServiceUnavailableException":
3833
2851
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
3834
- response = {
3835
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
3836
- name: errorCode,
3837
- $metadata: deserializeMetadata(output),
3838
- };
3839
- break;
2852
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
3840
2853
  case "ThrottledClientException":
3841
2854
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
3842
- response = {
3843
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
3844
- name: errorCode,
3845
- $metadata: deserializeMetadata(output),
3846
- };
3847
- break;
2855
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
3848
2856
  case "UnauthorizedClientException":
3849
2857
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
3850
- response = {
3851
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
3852
- name: errorCode,
3853
- $metadata: deserializeMetadata(output),
3854
- };
3855
- break;
2858
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
3856
2859
  default:
3857
2860
  const parsedBody = parsedOutput.body;
3858
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3859
- response = {
3860
- ...parsedBody,
3861
- name: `${errorCode}`,
3862
- message: parsedBody.message || parsedBody.Message || errorCode,
2861
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2862
+ name: parsedBody.code || parsedBody.Code || errorCode,
3863
2863
  $fault: "client",
3864
2864
  $metadata: deserializeMetadata(output),
3865
- };
2865
+ });
2866
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3866
2867
  }
3867
- const message = response.message || response.Message || errorCode;
3868
- response.message = message;
3869
- delete response.Message;
3870
- return Promise.reject(Object.assign(new Error(message), response));
3871
2868
  };
3872
2869
  const deserializeAws_restJson1GetMessagingSessionEndpointCommand = async (output, context) => {
3873
2870
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -3895,59 +2892,28 @@ const deserializeAws_restJson1GetMessagingSessionEndpointCommandError = async (o
3895
2892
  switch (errorCode) {
3896
2893
  case "ForbiddenException":
3897
2894
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
3898
- response = {
3899
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
3900
- name: errorCode,
3901
- $metadata: deserializeMetadata(output),
3902
- };
3903
- break;
2895
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
3904
2896
  case "ServiceFailureException":
3905
2897
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
3906
- response = {
3907
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
3908
- name: errorCode,
3909
- $metadata: deserializeMetadata(output),
3910
- };
3911
- break;
2898
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
3912
2899
  case "ServiceUnavailableException":
3913
2900
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
3914
- response = {
3915
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
3916
- name: errorCode,
3917
- $metadata: deserializeMetadata(output),
3918
- };
3919
- break;
2901
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
3920
2902
  case "ThrottledClientException":
3921
2903
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
3922
- response = {
3923
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
3924
- name: errorCode,
3925
- $metadata: deserializeMetadata(output),
3926
- };
3927
- break;
2904
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
3928
2905
  case "UnauthorizedClientException":
3929
2906
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
3930
- response = {
3931
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
3932
- name: errorCode,
3933
- $metadata: deserializeMetadata(output),
3934
- };
3935
- break;
2907
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
3936
2908
  default:
3937
2909
  const parsedBody = parsedOutput.body;
3938
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3939
- response = {
3940
- ...parsedBody,
3941
- name: `${errorCode}`,
3942
- message: parsedBody.message || parsedBody.Message || errorCode,
2910
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2911
+ name: parsedBody.code || parsedBody.Code || errorCode,
3943
2912
  $fault: "client",
3944
2913
  $metadata: deserializeMetadata(output),
3945
- };
2914
+ });
2915
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3946
2916
  }
3947
- const message = response.message || response.Message || errorCode;
3948
- response.message = message;
3949
- delete response.Message;
3950
- return Promise.reject(Object.assign(new Error(message), response));
3951
2917
  };
3952
2918
  const deserializeAws_restJson1ListChannelBansCommand = async (output, context) => {
3953
2919
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -3983,67 +2949,31 @@ const deserializeAws_restJson1ListChannelBansCommandError = async (output, conte
3983
2949
  switch (errorCode) {
3984
2950
  case "BadRequestException":
3985
2951
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
3986
- response = {
3987
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
3988
- name: errorCode,
3989
- $metadata: deserializeMetadata(output),
3990
- };
3991
- break;
2952
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
3992
2953
  case "ForbiddenException":
3993
2954
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
3994
- response = {
3995
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
3996
- name: errorCode,
3997
- $metadata: deserializeMetadata(output),
3998
- };
3999
- break;
2955
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
4000
2956
  case "ServiceFailureException":
4001
2957
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
4002
- response = {
4003
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
4004
- name: errorCode,
4005
- $metadata: deserializeMetadata(output),
4006
- };
4007
- break;
2958
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
4008
2959
  case "ServiceUnavailableException":
4009
2960
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
4010
- response = {
4011
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
4012
- name: errorCode,
4013
- $metadata: deserializeMetadata(output),
4014
- };
4015
- break;
2961
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
4016
2962
  case "ThrottledClientException":
4017
2963
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
4018
- response = {
4019
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
4020
- name: errorCode,
4021
- $metadata: deserializeMetadata(output),
4022
- };
4023
- break;
2964
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
4024
2965
  case "UnauthorizedClientException":
4025
2966
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
4026
- response = {
4027
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
4028
- name: errorCode,
4029
- $metadata: deserializeMetadata(output),
4030
- };
4031
- break;
2967
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
4032
2968
  default:
4033
2969
  const parsedBody = parsedOutput.body;
4034
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4035
- response = {
4036
- ...parsedBody,
4037
- name: `${errorCode}`,
4038
- message: parsedBody.message || parsedBody.Message || errorCode,
2970
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
2971
+ name: parsedBody.code || parsedBody.Code || errorCode,
4039
2972
  $fault: "client",
4040
2973
  $metadata: deserializeMetadata(output),
4041
- };
2974
+ });
2975
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4042
2976
  }
4043
- const message = response.message || response.Message || errorCode;
4044
- response.message = message;
4045
- delete response.Message;
4046
- return Promise.reject(Object.assign(new Error(message), response));
4047
2977
  };
4048
2978
  const deserializeAws_restJson1ListChannelFlowsCommand = async (output, context) => {
4049
2979
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -4075,67 +3005,31 @@ const deserializeAws_restJson1ListChannelFlowsCommandError = async (output, cont
4075
3005
  switch (errorCode) {
4076
3006
  case "BadRequestException":
4077
3007
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
4078
- response = {
4079
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
4080
- name: errorCode,
4081
- $metadata: deserializeMetadata(output),
4082
- };
4083
- break;
3008
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
4084
3009
  case "ForbiddenException":
4085
3010
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
4086
- response = {
4087
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
4088
- name: errorCode,
4089
- $metadata: deserializeMetadata(output),
4090
- };
4091
- break;
3011
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
4092
3012
  case "ServiceFailureException":
4093
3013
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
4094
- response = {
4095
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
4096
- name: errorCode,
4097
- $metadata: deserializeMetadata(output),
4098
- };
4099
- break;
3014
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
4100
3015
  case "ServiceUnavailableException":
4101
3016
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
4102
- response = {
4103
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
4104
- name: errorCode,
4105
- $metadata: deserializeMetadata(output),
4106
- };
4107
- break;
3017
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
4108
3018
  case "ThrottledClientException":
4109
3019
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
4110
- response = {
4111
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
4112
- name: errorCode,
4113
- $metadata: deserializeMetadata(output),
4114
- };
4115
- break;
3020
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
4116
3021
  case "UnauthorizedClientException":
4117
3022
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
4118
- response = {
4119
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
4120
- name: errorCode,
4121
- $metadata: deserializeMetadata(output),
4122
- };
4123
- break;
3023
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
4124
3024
  default:
4125
3025
  const parsedBody = parsedOutput.body;
4126
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4127
- response = {
4128
- ...parsedBody,
4129
- name: `${errorCode}`,
4130
- message: parsedBody.message || parsedBody.Message || errorCode,
3026
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3027
+ name: parsedBody.code || parsedBody.Code || errorCode,
4131
3028
  $fault: "client",
4132
3029
  $metadata: deserializeMetadata(output),
4133
- };
3030
+ });
3031
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4134
3032
  }
4135
- const message = response.message || response.Message || errorCode;
4136
- response.message = message;
4137
- delete response.Message;
4138
- return Promise.reject(Object.assign(new Error(message), response));
4139
3033
  };
4140
3034
  const deserializeAws_restJson1ListChannelMembershipsCommand = async (output, context) => {
4141
3035
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -4171,67 +3065,31 @@ const deserializeAws_restJson1ListChannelMembershipsCommandError = async (output
4171
3065
  switch (errorCode) {
4172
3066
  case "BadRequestException":
4173
3067
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
4174
- response = {
4175
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
4176
- name: errorCode,
4177
- $metadata: deserializeMetadata(output),
4178
- };
4179
- break;
3068
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
4180
3069
  case "ForbiddenException":
4181
3070
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
4182
- response = {
4183
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
4184
- name: errorCode,
4185
- $metadata: deserializeMetadata(output),
4186
- };
4187
- break;
3071
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
4188
3072
  case "ServiceFailureException":
4189
3073
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
4190
- response = {
4191
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
4192
- name: errorCode,
4193
- $metadata: deserializeMetadata(output),
4194
- };
4195
- break;
3074
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
4196
3075
  case "ServiceUnavailableException":
4197
3076
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
4198
- response = {
4199
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
4200
- name: errorCode,
4201
- $metadata: deserializeMetadata(output),
4202
- };
4203
- break;
3077
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
4204
3078
  case "ThrottledClientException":
4205
3079
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
4206
- response = {
4207
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
4208
- name: errorCode,
4209
- $metadata: deserializeMetadata(output),
4210
- };
4211
- break;
3080
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
4212
3081
  case "UnauthorizedClientException":
4213
3082
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
4214
- response = {
4215
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
4216
- name: errorCode,
4217
- $metadata: deserializeMetadata(output),
4218
- };
4219
- break;
3083
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
4220
3084
  default:
4221
3085
  const parsedBody = parsedOutput.body;
4222
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4223
- response = {
4224
- ...parsedBody,
4225
- name: `${errorCode}`,
4226
- message: parsedBody.message || parsedBody.Message || errorCode,
3086
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3087
+ name: parsedBody.code || parsedBody.Code || errorCode,
4227
3088
  $fault: "client",
4228
3089
  $metadata: deserializeMetadata(output),
4229
- };
3090
+ });
3091
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4230
3092
  }
4231
- const message = response.message || response.Message || errorCode;
4232
- response.message = message;
4233
- delete response.Message;
4234
- return Promise.reject(Object.assign(new Error(message), response));
4235
3093
  };
4236
3094
  const deserializeAws_restJson1ListChannelMembershipsForAppInstanceUserCommand = async (output, context) => {
4237
3095
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -4263,67 +3121,31 @@ const deserializeAws_restJson1ListChannelMembershipsForAppInstanceUserCommandErr
4263
3121
  switch (errorCode) {
4264
3122
  case "BadRequestException":
4265
3123
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
4266
- response = {
4267
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
4268
- name: errorCode,
4269
- $metadata: deserializeMetadata(output),
4270
- };
4271
- break;
3124
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
4272
3125
  case "ForbiddenException":
4273
3126
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
4274
- response = {
4275
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
4276
- name: errorCode,
4277
- $metadata: deserializeMetadata(output),
4278
- };
4279
- break;
3127
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
4280
3128
  case "ServiceFailureException":
4281
3129
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
4282
- response = {
4283
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
4284
- name: errorCode,
4285
- $metadata: deserializeMetadata(output),
4286
- };
4287
- break;
3130
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
4288
3131
  case "ServiceUnavailableException":
4289
3132
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
4290
- response = {
4291
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
4292
- name: errorCode,
4293
- $metadata: deserializeMetadata(output),
4294
- };
4295
- break;
3133
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
4296
3134
  case "ThrottledClientException":
4297
3135
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
4298
- response = {
4299
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
4300
- name: errorCode,
4301
- $metadata: deserializeMetadata(output),
4302
- };
4303
- break;
3136
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
4304
3137
  case "UnauthorizedClientException":
4305
3138
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
4306
- response = {
4307
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
4308
- name: errorCode,
4309
- $metadata: deserializeMetadata(output),
4310
- };
4311
- break;
3139
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
4312
3140
  default:
4313
3141
  const parsedBody = parsedOutput.body;
4314
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4315
- response = {
4316
- ...parsedBody,
4317
- name: `${errorCode}`,
4318
- message: parsedBody.message || parsedBody.Message || errorCode,
3142
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3143
+ name: parsedBody.code || parsedBody.Code || errorCode,
4319
3144
  $fault: "client",
4320
3145
  $metadata: deserializeMetadata(output),
4321
- };
3146
+ });
3147
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4322
3148
  }
4323
- const message = response.message || response.Message || errorCode;
4324
- response.message = message;
4325
- delete response.Message;
4326
- return Promise.reject(Object.assign(new Error(message), response));
4327
3149
  };
4328
3150
  const deserializeAws_restJson1ListChannelMessagesCommand = async (output, context) => {
4329
3151
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -4359,67 +3181,31 @@ const deserializeAws_restJson1ListChannelMessagesCommandError = async (output, c
4359
3181
  switch (errorCode) {
4360
3182
  case "BadRequestException":
4361
3183
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
4362
- response = {
4363
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
4364
- name: errorCode,
4365
- $metadata: deserializeMetadata(output),
4366
- };
4367
- break;
3184
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
4368
3185
  case "ForbiddenException":
4369
3186
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
4370
- response = {
4371
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
4372
- name: errorCode,
4373
- $metadata: deserializeMetadata(output),
4374
- };
4375
- break;
3187
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
4376
3188
  case "ServiceFailureException":
4377
3189
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
4378
- response = {
4379
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
4380
- name: errorCode,
4381
- $metadata: deserializeMetadata(output),
4382
- };
4383
- break;
3190
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
4384
3191
  case "ServiceUnavailableException":
4385
3192
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
4386
- response = {
4387
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
4388
- name: errorCode,
4389
- $metadata: deserializeMetadata(output),
4390
- };
4391
- break;
3193
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
4392
3194
  case "ThrottledClientException":
4393
3195
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
4394
- response = {
4395
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
4396
- name: errorCode,
4397
- $metadata: deserializeMetadata(output),
4398
- };
4399
- break;
3196
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
4400
3197
  case "UnauthorizedClientException":
4401
3198
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
4402
- response = {
4403
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
4404
- name: errorCode,
4405
- $metadata: deserializeMetadata(output),
4406
- };
4407
- break;
3199
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
4408
3200
  default:
4409
3201
  const parsedBody = parsedOutput.body;
4410
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4411
- response = {
4412
- ...parsedBody,
4413
- name: `${errorCode}`,
4414
- message: parsedBody.message || parsedBody.Message || errorCode,
3202
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3203
+ name: parsedBody.code || parsedBody.Code || errorCode,
4415
3204
  $fault: "client",
4416
3205
  $metadata: deserializeMetadata(output),
4417
- };
3206
+ });
3207
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4418
3208
  }
4419
- const message = response.message || response.Message || errorCode;
4420
- response.message = message;
4421
- delete response.Message;
4422
- return Promise.reject(Object.assign(new Error(message), response));
4423
3209
  };
4424
3210
  const deserializeAws_restJson1ListChannelModeratorsCommand = async (output, context) => {
4425
3211
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -4455,67 +3241,31 @@ const deserializeAws_restJson1ListChannelModeratorsCommandError = async (output,
4455
3241
  switch (errorCode) {
4456
3242
  case "BadRequestException":
4457
3243
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
4458
- response = {
4459
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
4460
- name: errorCode,
4461
- $metadata: deserializeMetadata(output),
4462
- };
4463
- break;
3244
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
4464
3245
  case "ForbiddenException":
4465
3246
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
4466
- response = {
4467
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
4468
- name: errorCode,
4469
- $metadata: deserializeMetadata(output),
4470
- };
4471
- break;
3247
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
4472
3248
  case "ServiceFailureException":
4473
3249
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
4474
- response = {
4475
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
4476
- name: errorCode,
4477
- $metadata: deserializeMetadata(output),
4478
- };
4479
- break;
3250
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
4480
3251
  case "ServiceUnavailableException":
4481
3252
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
4482
- response = {
4483
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
4484
- name: errorCode,
4485
- $metadata: deserializeMetadata(output),
4486
- };
4487
- break;
3253
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
4488
3254
  case "ThrottledClientException":
4489
3255
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
4490
- response = {
4491
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
4492
- name: errorCode,
4493
- $metadata: deserializeMetadata(output),
4494
- };
4495
- break;
3256
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
4496
3257
  case "UnauthorizedClientException":
4497
3258
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
4498
- response = {
4499
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
4500
- name: errorCode,
4501
- $metadata: deserializeMetadata(output),
4502
- };
4503
- break;
3259
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
4504
3260
  default:
4505
3261
  const parsedBody = parsedOutput.body;
4506
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4507
- response = {
4508
- ...parsedBody,
4509
- name: `${errorCode}`,
4510
- message: parsedBody.message || parsedBody.Message || errorCode,
3262
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3263
+ name: parsedBody.code || parsedBody.Code || errorCode,
4511
3264
  $fault: "client",
4512
3265
  $metadata: deserializeMetadata(output),
4513
- };
3266
+ });
3267
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4514
3268
  }
4515
- const message = response.message || response.Message || errorCode;
4516
- response.message = message;
4517
- delete response.Message;
4518
- return Promise.reject(Object.assign(new Error(message), response));
4519
3269
  };
4520
3270
  const deserializeAws_restJson1ListChannelsCommand = async (output, context) => {
4521
3271
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -4547,67 +3297,31 @@ const deserializeAws_restJson1ListChannelsCommandError = async (output, context)
4547
3297
  switch (errorCode) {
4548
3298
  case "BadRequestException":
4549
3299
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
4550
- response = {
4551
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
4552
- name: errorCode,
4553
- $metadata: deserializeMetadata(output),
4554
- };
4555
- break;
3300
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
4556
3301
  case "ForbiddenException":
4557
3302
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
4558
- response = {
4559
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
4560
- name: errorCode,
4561
- $metadata: deserializeMetadata(output),
4562
- };
4563
- break;
3303
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
4564
3304
  case "ServiceFailureException":
4565
3305
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
4566
- response = {
4567
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
4568
- name: errorCode,
4569
- $metadata: deserializeMetadata(output),
4570
- };
4571
- break;
3306
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
4572
3307
  case "ServiceUnavailableException":
4573
3308
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
4574
- response = {
4575
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
4576
- name: errorCode,
4577
- $metadata: deserializeMetadata(output),
4578
- };
4579
- break;
3309
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
4580
3310
  case "ThrottledClientException":
4581
3311
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
4582
- response = {
4583
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
4584
- name: errorCode,
4585
- $metadata: deserializeMetadata(output),
4586
- };
4587
- break;
3312
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
4588
3313
  case "UnauthorizedClientException":
4589
3314
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
4590
- response = {
4591
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
4592
- name: errorCode,
4593
- $metadata: deserializeMetadata(output),
4594
- };
4595
- break;
3315
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
4596
3316
  default:
4597
3317
  const parsedBody = parsedOutput.body;
4598
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4599
- response = {
4600
- ...parsedBody,
4601
- name: `${errorCode}`,
4602
- message: parsedBody.message || parsedBody.Message || errorCode,
3318
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3319
+ name: parsedBody.code || parsedBody.Code || errorCode,
4603
3320
  $fault: "client",
4604
3321
  $metadata: deserializeMetadata(output),
4605
- };
3322
+ });
3323
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4606
3324
  }
4607
- const message = response.message || response.Message || errorCode;
4608
- response.message = message;
4609
- delete response.Message;
4610
- return Promise.reject(Object.assign(new Error(message), response));
4611
3325
  };
4612
3326
  const deserializeAws_restJson1ListChannelsAssociatedWithChannelFlowCommand = async (output, context) => {
4613
3327
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -4639,67 +3353,31 @@ const deserializeAws_restJson1ListChannelsAssociatedWithChannelFlowCommandError
4639
3353
  switch (errorCode) {
4640
3354
  case "BadRequestException":
4641
3355
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
4642
- response = {
4643
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
4644
- name: errorCode,
4645
- $metadata: deserializeMetadata(output),
4646
- };
4647
- break;
3356
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
4648
3357
  case "ForbiddenException":
4649
3358
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
4650
- response = {
4651
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
4652
- name: errorCode,
4653
- $metadata: deserializeMetadata(output),
4654
- };
4655
- break;
3359
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
4656
3360
  case "ServiceFailureException":
4657
3361
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
4658
- response = {
4659
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
4660
- name: errorCode,
4661
- $metadata: deserializeMetadata(output),
4662
- };
4663
- break;
3362
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
4664
3363
  case "ServiceUnavailableException":
4665
3364
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
4666
- response = {
4667
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
4668
- name: errorCode,
4669
- $metadata: deserializeMetadata(output),
4670
- };
4671
- break;
3365
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
4672
3366
  case "ThrottledClientException":
4673
3367
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
4674
- response = {
4675
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
4676
- name: errorCode,
4677
- $metadata: deserializeMetadata(output),
4678
- };
4679
- break;
3368
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
4680
3369
  case "UnauthorizedClientException":
4681
3370
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
4682
- response = {
4683
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
4684
- name: errorCode,
4685
- $metadata: deserializeMetadata(output),
4686
- };
4687
- break;
3371
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
4688
3372
  default:
4689
3373
  const parsedBody = parsedOutput.body;
4690
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4691
- response = {
4692
- ...parsedBody,
4693
- name: `${errorCode}`,
4694
- message: parsedBody.message || parsedBody.Message || errorCode,
3374
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3375
+ name: parsedBody.code || parsedBody.Code || errorCode,
4695
3376
  $fault: "client",
4696
3377
  $metadata: deserializeMetadata(output),
4697
- };
3378
+ });
3379
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4698
3380
  }
4699
- const message = response.message || response.Message || errorCode;
4700
- response.message = message;
4701
- delete response.Message;
4702
- return Promise.reject(Object.assign(new Error(message), response));
4703
3381
  };
4704
3382
  const deserializeAws_restJson1ListChannelsModeratedByAppInstanceUserCommand = async (output, context) => {
4705
3383
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -4731,67 +3409,31 @@ const deserializeAws_restJson1ListChannelsModeratedByAppInstanceUserCommandError
4731
3409
  switch (errorCode) {
4732
3410
  case "BadRequestException":
4733
3411
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
4734
- response = {
4735
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
4736
- name: errorCode,
4737
- $metadata: deserializeMetadata(output),
4738
- };
4739
- break;
3412
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
4740
3413
  case "ForbiddenException":
4741
3414
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
4742
- response = {
4743
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
4744
- name: errorCode,
4745
- $metadata: deserializeMetadata(output),
4746
- };
4747
- break;
3415
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
4748
3416
  case "ServiceFailureException":
4749
3417
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
4750
- response = {
4751
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
4752
- name: errorCode,
4753
- $metadata: deserializeMetadata(output),
4754
- };
4755
- break;
3418
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
4756
3419
  case "ServiceUnavailableException":
4757
3420
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
4758
- response = {
4759
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
4760
- name: errorCode,
4761
- $metadata: deserializeMetadata(output),
4762
- };
4763
- break;
3421
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
4764
3422
  case "ThrottledClientException":
4765
3423
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
4766
- response = {
4767
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
4768
- name: errorCode,
4769
- $metadata: deserializeMetadata(output),
4770
- };
4771
- break;
3424
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
4772
3425
  case "UnauthorizedClientException":
4773
3426
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
4774
- response = {
4775
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
4776
- name: errorCode,
4777
- $metadata: deserializeMetadata(output),
4778
- };
4779
- break;
3427
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
4780
3428
  default:
4781
3429
  const parsedBody = parsedOutput.body;
4782
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4783
- response = {
4784
- ...parsedBody,
4785
- name: `${errorCode}`,
4786
- message: parsedBody.message || parsedBody.Message || errorCode,
3430
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3431
+ name: parsedBody.code || parsedBody.Code || errorCode,
4787
3432
  $fault: "client",
4788
3433
  $metadata: deserializeMetadata(output),
4789
- };
3434
+ });
3435
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4790
3436
  }
4791
- const message = response.message || response.Message || errorCode;
4792
- response.message = message;
4793
- delete response.Message;
4794
- return Promise.reject(Object.assign(new Error(message), response));
4795
3437
  };
4796
3438
  const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
4797
3439
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -4819,67 +3461,31 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
4819
3461
  switch (errorCode) {
4820
3462
  case "BadRequestException":
4821
3463
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
4822
- response = {
4823
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
4824
- name: errorCode,
4825
- $metadata: deserializeMetadata(output),
4826
- };
4827
- break;
3464
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
4828
3465
  case "ForbiddenException":
4829
3466
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
4830
- response = {
4831
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
4832
- name: errorCode,
4833
- $metadata: deserializeMetadata(output),
4834
- };
4835
- break;
3467
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
4836
3468
  case "ServiceFailureException":
4837
3469
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
4838
- response = {
4839
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
4840
- name: errorCode,
4841
- $metadata: deserializeMetadata(output),
4842
- };
4843
- break;
3470
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
4844
3471
  case "ServiceUnavailableException":
4845
3472
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
4846
- response = {
4847
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
4848
- name: errorCode,
4849
- $metadata: deserializeMetadata(output),
4850
- };
4851
- break;
3473
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
4852
3474
  case "ThrottledClientException":
4853
3475
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
4854
- response = {
4855
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
4856
- name: errorCode,
4857
- $metadata: deserializeMetadata(output),
4858
- };
4859
- break;
3476
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
4860
3477
  case "UnauthorizedClientException":
4861
3478
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
4862
- response = {
4863
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
4864
- name: errorCode,
4865
- $metadata: deserializeMetadata(output),
4866
- };
4867
- break;
3479
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
4868
3480
  default:
4869
3481
  const parsedBody = parsedOutput.body;
4870
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4871
- response = {
4872
- ...parsedBody,
4873
- name: `${errorCode}`,
4874
- message: parsedBody.message || parsedBody.Message || errorCode,
3482
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3483
+ name: parsedBody.code || parsedBody.Code || errorCode,
4875
3484
  $fault: "client",
4876
3485
  $metadata: deserializeMetadata(output),
4877
- };
3486
+ });
3487
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4878
3488
  }
4879
- const message = response.message || response.Message || errorCode;
4880
- response.message = message;
4881
- delete response.Message;
4882
- return Promise.reject(Object.assign(new Error(message), response));
4883
3489
  };
4884
3490
  const deserializeAws_restJson1PutChannelMembershipPreferencesCommand = async (output, context) => {
4885
3491
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -4915,75 +3521,34 @@ const deserializeAws_restJson1PutChannelMembershipPreferencesCommandError = asyn
4915
3521
  switch (errorCode) {
4916
3522
  case "BadRequestException":
4917
3523
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
4918
- response = {
4919
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
4920
- name: errorCode,
4921
- $metadata: deserializeMetadata(output),
4922
- };
4923
- break;
3524
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
4924
3525
  case "ConflictException":
4925
3526
  case "com.amazonaws.chimesdkmessaging#ConflictException":
4926
- response = {
4927
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
4928
- name: errorCode,
4929
- $metadata: deserializeMetadata(output),
4930
- };
4931
- break;
3527
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
4932
3528
  case "ForbiddenException":
4933
3529
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
4934
- response = {
4935
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
4936
- name: errorCode,
4937
- $metadata: deserializeMetadata(output),
4938
- };
4939
- break;
3530
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
4940
3531
  case "ServiceFailureException":
4941
3532
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
4942
- response = {
4943
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
4944
- name: errorCode,
4945
- $metadata: deserializeMetadata(output),
4946
- };
4947
- break;
3533
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
4948
3534
  case "ServiceUnavailableException":
4949
3535
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
4950
- response = {
4951
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
4952
- name: errorCode,
4953
- $metadata: deserializeMetadata(output),
4954
- };
4955
- break;
3536
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
4956
3537
  case "ThrottledClientException":
4957
3538
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
4958
- response = {
4959
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
4960
- name: errorCode,
4961
- $metadata: deserializeMetadata(output),
4962
- };
4963
- break;
3539
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
4964
3540
  case "UnauthorizedClientException":
4965
3541
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
4966
- response = {
4967
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
4968
- name: errorCode,
4969
- $metadata: deserializeMetadata(output),
4970
- };
4971
- break;
3542
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
4972
3543
  default:
4973
3544
  const parsedBody = parsedOutput.body;
4974
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4975
- response = {
4976
- ...parsedBody,
4977
- name: `${errorCode}`,
4978
- message: parsedBody.message || parsedBody.Message || errorCode,
3545
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3546
+ name: parsedBody.code || parsedBody.Code || errorCode,
4979
3547
  $fault: "client",
4980
3548
  $metadata: deserializeMetadata(output),
4981
- };
3549
+ });
3550
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4982
3551
  }
4983
- const message = response.message || response.Message || errorCode;
4984
- response.message = message;
4985
- delete response.Message;
4986
- return Promise.reject(Object.assign(new Error(message), response));
4987
3552
  };
4988
3553
  const deserializeAws_restJson1RedactChannelMessageCommand = async (output, context) => {
4989
3554
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -5015,67 +3580,31 @@ const deserializeAws_restJson1RedactChannelMessageCommandError = async (output,
5015
3580
  switch (errorCode) {
5016
3581
  case "BadRequestException":
5017
3582
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
5018
- response = {
5019
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
5020
- name: errorCode,
5021
- $metadata: deserializeMetadata(output),
5022
- };
5023
- break;
3583
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
5024
3584
  case "ForbiddenException":
5025
3585
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
5026
- response = {
5027
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
5028
- name: errorCode,
5029
- $metadata: deserializeMetadata(output),
5030
- };
5031
- break;
3586
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
5032
3587
  case "ServiceFailureException":
5033
3588
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
5034
- response = {
5035
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
5036
- name: errorCode,
5037
- $metadata: deserializeMetadata(output),
5038
- };
5039
- break;
3589
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
5040
3590
  case "ServiceUnavailableException":
5041
3591
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
5042
- response = {
5043
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
5044
- name: errorCode,
5045
- $metadata: deserializeMetadata(output),
5046
- };
5047
- break;
3592
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
5048
3593
  case "ThrottledClientException":
5049
3594
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
5050
- response = {
5051
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
5052
- name: errorCode,
5053
- $metadata: deserializeMetadata(output),
5054
- };
5055
- break;
3595
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
5056
3596
  case "UnauthorizedClientException":
5057
3597
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
5058
- response = {
5059
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
5060
- name: errorCode,
5061
- $metadata: deserializeMetadata(output),
5062
- };
5063
- break;
3598
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
5064
3599
  default:
5065
3600
  const parsedBody = parsedOutput.body;
5066
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
5067
- response = {
5068
- ...parsedBody,
5069
- name: `${errorCode}`,
5070
- message: parsedBody.message || parsedBody.Message || errorCode,
3601
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3602
+ name: parsedBody.code || parsedBody.Code || errorCode,
5071
3603
  $fault: "client",
5072
3604
  $metadata: deserializeMetadata(output),
5073
- };
3605
+ });
3606
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
5074
3607
  }
5075
- const message = response.message || response.Message || errorCode;
5076
- response.message = message;
5077
- delete response.Message;
5078
- return Promise.reject(Object.assign(new Error(message), response));
5079
3608
  };
5080
3609
  const deserializeAws_restJson1SendChannelMessageCommand = async (output, context) => {
5081
3610
  if (output.statusCode !== 201 && output.statusCode >= 300) {
@@ -5111,75 +3640,34 @@ const deserializeAws_restJson1SendChannelMessageCommandError = async (output, co
5111
3640
  switch (errorCode) {
5112
3641
  case "BadRequestException":
5113
3642
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
5114
- response = {
5115
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
5116
- name: errorCode,
5117
- $metadata: deserializeMetadata(output),
5118
- };
5119
- break;
3643
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
5120
3644
  case "ConflictException":
5121
3645
  case "com.amazonaws.chimesdkmessaging#ConflictException":
5122
- response = {
5123
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
5124
- name: errorCode,
5125
- $metadata: deserializeMetadata(output),
5126
- };
5127
- break;
3646
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
5128
3647
  case "ForbiddenException":
5129
3648
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
5130
- response = {
5131
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
5132
- name: errorCode,
5133
- $metadata: deserializeMetadata(output),
5134
- };
5135
- break;
3649
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
5136
3650
  case "ServiceFailureException":
5137
3651
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
5138
- response = {
5139
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
5140
- name: errorCode,
5141
- $metadata: deserializeMetadata(output),
5142
- };
5143
- break;
3652
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
5144
3653
  case "ServiceUnavailableException":
5145
3654
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
5146
- response = {
5147
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
5148
- name: errorCode,
5149
- $metadata: deserializeMetadata(output),
5150
- };
5151
- break;
3655
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
5152
3656
  case "ThrottledClientException":
5153
3657
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
5154
- response = {
5155
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
5156
- name: errorCode,
5157
- $metadata: deserializeMetadata(output),
5158
- };
5159
- break;
3658
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
5160
3659
  case "UnauthorizedClientException":
5161
3660
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
5162
- response = {
5163
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
5164
- name: errorCode,
5165
- $metadata: deserializeMetadata(output),
5166
- };
5167
- break;
3661
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
5168
3662
  default:
5169
3663
  const parsedBody = parsedOutput.body;
5170
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
5171
- response = {
5172
- ...parsedBody,
5173
- name: `${errorCode}`,
5174
- message: parsedBody.message || parsedBody.Message || errorCode,
3664
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3665
+ name: parsedBody.code || parsedBody.Code || errorCode,
5175
3666
  $fault: "client",
5176
3667
  $metadata: deserializeMetadata(output),
5177
- };
3668
+ });
3669
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
5178
3670
  }
5179
- const message = response.message || response.Message || errorCode;
5180
- response.message = message;
5181
- delete response.Message;
5182
- return Promise.reject(Object.assign(new Error(message), response));
5183
3671
  };
5184
3672
  const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
5185
3673
  if (output.statusCode !== 204 && output.statusCode >= 300) {
@@ -5203,75 +3691,34 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
5203
3691
  switch (errorCode) {
5204
3692
  case "BadRequestException":
5205
3693
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
5206
- response = {
5207
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
5208
- name: errorCode,
5209
- $metadata: deserializeMetadata(output),
5210
- };
5211
- break;
3694
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
5212
3695
  case "ForbiddenException":
5213
3696
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
5214
- response = {
5215
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
5216
- name: errorCode,
5217
- $metadata: deserializeMetadata(output),
5218
- };
5219
- break;
3697
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
5220
3698
  case "ResourceLimitExceededException":
5221
3699
  case "com.amazonaws.chimesdkmessaging#ResourceLimitExceededException":
5222
- response = {
5223
- ...(await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context)),
5224
- name: errorCode,
5225
- $metadata: deserializeMetadata(output),
5226
- };
5227
- break;
3700
+ throw await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context);
5228
3701
  case "ServiceFailureException":
5229
3702
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
5230
- response = {
5231
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
5232
- name: errorCode,
5233
- $metadata: deserializeMetadata(output),
5234
- };
5235
- break;
3703
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
5236
3704
  case "ServiceUnavailableException":
5237
3705
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
5238
- response = {
5239
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
5240
- name: errorCode,
5241
- $metadata: deserializeMetadata(output),
5242
- };
5243
- break;
3706
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
5244
3707
  case "ThrottledClientException":
5245
3708
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
5246
- response = {
5247
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
5248
- name: errorCode,
5249
- $metadata: deserializeMetadata(output),
5250
- };
5251
- break;
3709
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
5252
3710
  case "UnauthorizedClientException":
5253
3711
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
5254
- response = {
5255
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
5256
- name: errorCode,
5257
- $metadata: deserializeMetadata(output),
5258
- };
5259
- break;
3712
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
5260
3713
  default:
5261
3714
  const parsedBody = parsedOutput.body;
5262
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
5263
- response = {
5264
- ...parsedBody,
5265
- name: `${errorCode}`,
5266
- message: parsedBody.message || parsedBody.Message || errorCode,
3715
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3716
+ name: parsedBody.code || parsedBody.Code || errorCode,
5267
3717
  $fault: "client",
5268
3718
  $metadata: deserializeMetadata(output),
5269
- };
3719
+ });
3720
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
5270
3721
  }
5271
- const message = response.message || response.Message || errorCode;
5272
- response.message = message;
5273
- delete response.Message;
5274
- return Promise.reject(Object.assign(new Error(message), response));
5275
3722
  };
5276
3723
  const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
5277
3724
  if (output.statusCode !== 204 && output.statusCode >= 300) {
@@ -5295,67 +3742,31 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
5295
3742
  switch (errorCode) {
5296
3743
  case "BadRequestException":
5297
3744
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
5298
- response = {
5299
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
5300
- name: errorCode,
5301
- $metadata: deserializeMetadata(output),
5302
- };
5303
- break;
3745
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
5304
3746
  case "ForbiddenException":
5305
3747
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
5306
- response = {
5307
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
5308
- name: errorCode,
5309
- $metadata: deserializeMetadata(output),
5310
- };
5311
- break;
3748
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
5312
3749
  case "ServiceFailureException":
5313
3750
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
5314
- response = {
5315
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
5316
- name: errorCode,
5317
- $metadata: deserializeMetadata(output),
5318
- };
5319
- break;
3751
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
5320
3752
  case "ServiceUnavailableException":
5321
3753
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
5322
- response = {
5323
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
5324
- name: errorCode,
5325
- $metadata: deserializeMetadata(output),
5326
- };
5327
- break;
3754
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
5328
3755
  case "ThrottledClientException":
5329
3756
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
5330
- response = {
5331
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
5332
- name: errorCode,
5333
- $metadata: deserializeMetadata(output),
5334
- };
5335
- break;
3757
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
5336
3758
  case "UnauthorizedClientException":
5337
3759
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
5338
- response = {
5339
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
5340
- name: errorCode,
5341
- $metadata: deserializeMetadata(output),
5342
- };
5343
- break;
3760
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
5344
3761
  default:
5345
3762
  const parsedBody = parsedOutput.body;
5346
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
5347
- response = {
5348
- ...parsedBody,
5349
- name: `${errorCode}`,
5350
- message: parsedBody.message || parsedBody.Message || errorCode,
3763
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3764
+ name: parsedBody.code || parsedBody.Code || errorCode,
5351
3765
  $fault: "client",
5352
3766
  $metadata: deserializeMetadata(output),
5353
- };
3767
+ });
3768
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
5354
3769
  }
5355
- const message = response.message || response.Message || errorCode;
5356
- response.message = message;
5357
- delete response.Message;
5358
- return Promise.reject(Object.assign(new Error(message), response));
5359
3770
  };
5360
3771
  const deserializeAws_restJson1UpdateChannelCommand = async (output, context) => {
5361
3772
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -5383,75 +3794,34 @@ const deserializeAws_restJson1UpdateChannelCommandError = async (output, context
5383
3794
  switch (errorCode) {
5384
3795
  case "BadRequestException":
5385
3796
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
5386
- response = {
5387
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
5388
- name: errorCode,
5389
- $metadata: deserializeMetadata(output),
5390
- };
5391
- break;
3797
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
5392
3798
  case "ConflictException":
5393
3799
  case "com.amazonaws.chimesdkmessaging#ConflictException":
5394
- response = {
5395
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
5396
- name: errorCode,
5397
- $metadata: deserializeMetadata(output),
5398
- };
5399
- break;
3800
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
5400
3801
  case "ForbiddenException":
5401
3802
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
5402
- response = {
5403
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
5404
- name: errorCode,
5405
- $metadata: deserializeMetadata(output),
5406
- };
5407
- break;
3803
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
5408
3804
  case "ServiceFailureException":
5409
3805
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
5410
- response = {
5411
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
5412
- name: errorCode,
5413
- $metadata: deserializeMetadata(output),
5414
- };
5415
- break;
3806
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
5416
3807
  case "ServiceUnavailableException":
5417
3808
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
5418
- response = {
5419
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
5420
- name: errorCode,
5421
- $metadata: deserializeMetadata(output),
5422
- };
5423
- break;
3809
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
5424
3810
  case "ThrottledClientException":
5425
3811
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
5426
- response = {
5427
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
5428
- name: errorCode,
5429
- $metadata: deserializeMetadata(output),
5430
- };
5431
- break;
3812
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
5432
3813
  case "UnauthorizedClientException":
5433
3814
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
5434
- response = {
5435
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
5436
- name: errorCode,
5437
- $metadata: deserializeMetadata(output),
5438
- };
5439
- break;
3815
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
5440
3816
  default:
5441
3817
  const parsedBody = parsedOutput.body;
5442
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
5443
- response = {
5444
- ...parsedBody,
5445
- name: `${errorCode}`,
5446
- message: parsedBody.message || parsedBody.Message || errorCode,
3818
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3819
+ name: parsedBody.code || parsedBody.Code || errorCode,
5447
3820
  $fault: "client",
5448
3821
  $metadata: deserializeMetadata(output),
5449
- };
3822
+ });
3823
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
5450
3824
  }
5451
- const message = response.message || response.Message || errorCode;
5452
- response.message = message;
5453
- delete response.Message;
5454
- return Promise.reject(Object.assign(new Error(message), response));
5455
3825
  };
5456
3826
  const deserializeAws_restJson1UpdateChannelFlowCommand = async (output, context) => {
5457
3827
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -5479,75 +3849,34 @@ const deserializeAws_restJson1UpdateChannelFlowCommandError = async (output, con
5479
3849
  switch (errorCode) {
5480
3850
  case "BadRequestException":
5481
3851
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
5482
- response = {
5483
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
5484
- name: errorCode,
5485
- $metadata: deserializeMetadata(output),
5486
- };
5487
- break;
3852
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
5488
3853
  case "ConflictException":
5489
3854
  case "com.amazonaws.chimesdkmessaging#ConflictException":
5490
- response = {
5491
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
5492
- name: errorCode,
5493
- $metadata: deserializeMetadata(output),
5494
- };
5495
- break;
3855
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
5496
3856
  case "ForbiddenException":
5497
3857
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
5498
- response = {
5499
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
5500
- name: errorCode,
5501
- $metadata: deserializeMetadata(output),
5502
- };
5503
- break;
3858
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
5504
3859
  case "ServiceFailureException":
5505
3860
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
5506
- response = {
5507
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
5508
- name: errorCode,
5509
- $metadata: deserializeMetadata(output),
5510
- };
5511
- break;
3861
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
5512
3862
  case "ServiceUnavailableException":
5513
3863
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
5514
- response = {
5515
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
5516
- name: errorCode,
5517
- $metadata: deserializeMetadata(output),
5518
- };
5519
- break;
3864
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
5520
3865
  case "ThrottledClientException":
5521
3866
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
5522
- response = {
5523
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
5524
- name: errorCode,
5525
- $metadata: deserializeMetadata(output),
5526
- };
5527
- break;
3867
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
5528
3868
  case "UnauthorizedClientException":
5529
3869
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
5530
- response = {
5531
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
5532
- name: errorCode,
5533
- $metadata: deserializeMetadata(output),
5534
- };
5535
- break;
3870
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
5536
3871
  default:
5537
3872
  const parsedBody = parsedOutput.body;
5538
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
5539
- response = {
5540
- ...parsedBody,
5541
- name: `${errorCode}`,
5542
- message: parsedBody.message || parsedBody.Message || errorCode,
3873
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3874
+ name: parsedBody.code || parsedBody.Code || errorCode,
5543
3875
  $fault: "client",
5544
3876
  $metadata: deserializeMetadata(output),
5545
- };
3877
+ });
3878
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
5546
3879
  }
5547
- const message = response.message || response.Message || errorCode;
5548
- response.message = message;
5549
- delete response.Message;
5550
- return Promise.reject(Object.assign(new Error(message), response));
5551
3880
  };
5552
3881
  const deserializeAws_restJson1UpdateChannelMessageCommand = async (output, context) => {
5553
3882
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -5583,75 +3912,34 @@ const deserializeAws_restJson1UpdateChannelMessageCommandError = async (output,
5583
3912
  switch (errorCode) {
5584
3913
  case "BadRequestException":
5585
3914
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
5586
- response = {
5587
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
5588
- name: errorCode,
5589
- $metadata: deserializeMetadata(output),
5590
- };
5591
- break;
3915
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
5592
3916
  case "ConflictException":
5593
3917
  case "com.amazonaws.chimesdkmessaging#ConflictException":
5594
- response = {
5595
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
5596
- name: errorCode,
5597
- $metadata: deserializeMetadata(output),
5598
- };
5599
- break;
3918
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
5600
3919
  case "ForbiddenException":
5601
3920
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
5602
- response = {
5603
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
5604
- name: errorCode,
5605
- $metadata: deserializeMetadata(output),
5606
- };
5607
- break;
3921
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
5608
3922
  case "ServiceFailureException":
5609
3923
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
5610
- response = {
5611
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
5612
- name: errorCode,
5613
- $metadata: deserializeMetadata(output),
5614
- };
5615
- break;
3924
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
5616
3925
  case "ServiceUnavailableException":
5617
3926
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
5618
- response = {
5619
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
5620
- name: errorCode,
5621
- $metadata: deserializeMetadata(output),
5622
- };
5623
- break;
3927
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
5624
3928
  case "ThrottledClientException":
5625
3929
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
5626
- response = {
5627
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
5628
- name: errorCode,
5629
- $metadata: deserializeMetadata(output),
5630
- };
5631
- break;
3930
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
5632
3931
  case "UnauthorizedClientException":
5633
3932
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
5634
- response = {
5635
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
5636
- name: errorCode,
5637
- $metadata: deserializeMetadata(output),
5638
- };
5639
- break;
3933
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
5640
3934
  default:
5641
3935
  const parsedBody = parsedOutput.body;
5642
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
5643
- response = {
5644
- ...parsedBody,
5645
- name: `${errorCode}`,
5646
- message: parsedBody.message || parsedBody.Message || errorCode,
3936
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3937
+ name: parsedBody.code || parsedBody.Code || errorCode,
5647
3938
  $fault: "client",
5648
3939
  $metadata: deserializeMetadata(output),
5649
- };
3940
+ });
3941
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
5650
3942
  }
5651
- const message = response.message || response.Message || errorCode;
5652
- response.message = message;
5653
- delete response.Message;
5654
- return Promise.reject(Object.assign(new Error(message), response));
5655
3943
  };
5656
3944
  const deserializeAws_restJson1UpdateChannelReadMarkerCommand = async (output, context) => {
5657
3945
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -5679,84 +3967,37 @@ const deserializeAws_restJson1UpdateChannelReadMarkerCommandError = async (outpu
5679
3967
  switch (errorCode) {
5680
3968
  case "BadRequestException":
5681
3969
  case "com.amazonaws.chimesdkmessaging#BadRequestException":
5682
- response = {
5683
- ...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
5684
- name: errorCode,
5685
- $metadata: deserializeMetadata(output),
5686
- };
5687
- break;
3970
+ throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
5688
3971
  case "ConflictException":
5689
3972
  case "com.amazonaws.chimesdkmessaging#ConflictException":
5690
- response = {
5691
- ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
5692
- name: errorCode,
5693
- $metadata: deserializeMetadata(output),
5694
- };
5695
- break;
3973
+ throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
5696
3974
  case "ForbiddenException":
5697
3975
  case "com.amazonaws.chimesdkmessaging#ForbiddenException":
5698
- response = {
5699
- ...(await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)),
5700
- name: errorCode,
5701
- $metadata: deserializeMetadata(output),
5702
- };
5703
- break;
3976
+ throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
5704
3977
  case "ServiceFailureException":
5705
3978
  case "com.amazonaws.chimesdkmessaging#ServiceFailureException":
5706
- response = {
5707
- ...(await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context)),
5708
- name: errorCode,
5709
- $metadata: deserializeMetadata(output),
5710
- };
5711
- break;
3979
+ throw await deserializeAws_restJson1ServiceFailureExceptionResponse(parsedOutput, context);
5712
3980
  case "ServiceUnavailableException":
5713
3981
  case "com.amazonaws.chimesdkmessaging#ServiceUnavailableException":
5714
- response = {
5715
- ...(await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)),
5716
- name: errorCode,
5717
- $metadata: deserializeMetadata(output),
5718
- };
5719
- break;
3982
+ throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
5720
3983
  case "ThrottledClientException":
5721
3984
  case "com.amazonaws.chimesdkmessaging#ThrottledClientException":
5722
- response = {
5723
- ...(await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context)),
5724
- name: errorCode,
5725
- $metadata: deserializeMetadata(output),
5726
- };
5727
- break;
3985
+ throw await deserializeAws_restJson1ThrottledClientExceptionResponse(parsedOutput, context);
5728
3986
  case "UnauthorizedClientException":
5729
3987
  case "com.amazonaws.chimesdkmessaging#UnauthorizedClientException":
5730
- response = {
5731
- ...(await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context)),
5732
- name: errorCode,
5733
- $metadata: deserializeMetadata(output),
5734
- };
5735
- break;
3988
+ throw await deserializeAws_restJson1UnauthorizedClientExceptionResponse(parsedOutput, context);
5736
3989
  default:
5737
3990
  const parsedBody = parsedOutput.body;
5738
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
5739
- response = {
5740
- ...parsedBody,
5741
- name: `${errorCode}`,
5742
- message: parsedBody.message || parsedBody.Message || errorCode,
3991
+ response = new ChimeSDKMessagingServiceException_1.ChimeSDKMessagingServiceException({
3992
+ name: parsedBody.code || parsedBody.Code || errorCode,
5743
3993
  $fault: "client",
5744
3994
  $metadata: deserializeMetadata(output),
5745
- };
3995
+ });
3996
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
5746
3997
  }
5747
- const message = response.message || response.Message || errorCode;
5748
- response.message = message;
5749
- delete response.Message;
5750
- return Promise.reject(Object.assign(new Error(message), response));
5751
3998
  };
5752
3999
  const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput, context) => {
5753
- const contents = {
5754
- name: "BadRequestException",
5755
- $fault: "client",
5756
- $metadata: deserializeMetadata(parsedOutput),
5757
- Code: undefined,
5758
- Message: undefined,
5759
- };
4000
+ const contents = {};
5760
4001
  const data = parsedOutput.body;
5761
4002
  if (data.Code !== undefined && data.Code !== null) {
5762
4003
  contents.Code = smithy_client_1.expectString(data.Code);
@@ -5764,16 +4005,14 @@ const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput,
5764
4005
  if (data.Message !== undefined && data.Message !== null) {
5765
4006
  contents.Message = smithy_client_1.expectString(data.Message);
5766
4007
  }
5767
- return contents;
4008
+ const exception = new models_0_1.BadRequestException({
4009
+ $metadata: deserializeMetadata(parsedOutput),
4010
+ ...contents,
4011
+ });
4012
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
5768
4013
  };
5769
4014
  const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
5770
- const contents = {
5771
- name: "ConflictException",
5772
- $fault: "client",
5773
- $metadata: deserializeMetadata(parsedOutput),
5774
- Code: undefined,
5775
- Message: undefined,
5776
- };
4015
+ const contents = {};
5777
4016
  const data = parsedOutput.body;
5778
4017
  if (data.Code !== undefined && data.Code !== null) {
5779
4018
  contents.Code = smithy_client_1.expectString(data.Code);
@@ -5781,16 +4020,14 @@ const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, c
5781
4020
  if (data.Message !== undefined && data.Message !== null) {
5782
4021
  contents.Message = smithy_client_1.expectString(data.Message);
5783
4022
  }
5784
- return contents;
4023
+ const exception = new models_0_1.ConflictException({
4024
+ $metadata: deserializeMetadata(parsedOutput),
4025
+ ...contents,
4026
+ });
4027
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
5785
4028
  };
5786
4029
  const deserializeAws_restJson1ForbiddenExceptionResponse = async (parsedOutput, context) => {
5787
- const contents = {
5788
- name: "ForbiddenException",
5789
- $fault: "client",
5790
- $metadata: deserializeMetadata(parsedOutput),
5791
- Code: undefined,
5792
- Message: undefined,
5793
- };
4030
+ const contents = {};
5794
4031
  const data = parsedOutput.body;
5795
4032
  if (data.Code !== undefined && data.Code !== null) {
5796
4033
  contents.Code = smithy_client_1.expectString(data.Code);
@@ -5798,16 +4035,14 @@ const deserializeAws_restJson1ForbiddenExceptionResponse = async (parsedOutput,
5798
4035
  if (data.Message !== undefined && data.Message !== null) {
5799
4036
  contents.Message = smithy_client_1.expectString(data.Message);
5800
4037
  }
5801
- return contents;
4038
+ const exception = new models_0_1.ForbiddenException({
4039
+ $metadata: deserializeMetadata(parsedOutput),
4040
+ ...contents,
4041
+ });
4042
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
5802
4043
  };
5803
4044
  const deserializeAws_restJson1NotFoundExceptionResponse = async (parsedOutput, context) => {
5804
- const contents = {
5805
- name: "NotFoundException",
5806
- $fault: "client",
5807
- $metadata: deserializeMetadata(parsedOutput),
5808
- Code: undefined,
5809
- Message: undefined,
5810
- };
4045
+ const contents = {};
5811
4046
  const data = parsedOutput.body;
5812
4047
  if (data.Code !== undefined && data.Code !== null) {
5813
4048
  contents.Code = smithy_client_1.expectString(data.Code);
@@ -5815,16 +4050,14 @@ const deserializeAws_restJson1NotFoundExceptionResponse = async (parsedOutput, c
5815
4050
  if (data.Message !== undefined && data.Message !== null) {
5816
4051
  contents.Message = smithy_client_1.expectString(data.Message);
5817
4052
  }
5818
- return contents;
4053
+ const exception = new models_0_1.NotFoundException({
4054
+ $metadata: deserializeMetadata(parsedOutput),
4055
+ ...contents,
4056
+ });
4057
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
5819
4058
  };
5820
4059
  const deserializeAws_restJson1ResourceLimitExceededExceptionResponse = async (parsedOutput, context) => {
5821
- const contents = {
5822
- name: "ResourceLimitExceededException",
5823
- $fault: "client",
5824
- $metadata: deserializeMetadata(parsedOutput),
5825
- Code: undefined,
5826
- Message: undefined,
5827
- };
4060
+ const contents = {};
5828
4061
  const data = parsedOutput.body;
5829
4062
  if (data.Code !== undefined && data.Code !== null) {
5830
4063
  contents.Code = smithy_client_1.expectString(data.Code);
@@ -5832,16 +4065,14 @@ const deserializeAws_restJson1ResourceLimitExceededExceptionResponse = async (pa
5832
4065
  if (data.Message !== undefined && data.Message !== null) {
5833
4066
  contents.Message = smithy_client_1.expectString(data.Message);
5834
4067
  }
5835
- return contents;
4068
+ const exception = new models_0_1.ResourceLimitExceededException({
4069
+ $metadata: deserializeMetadata(parsedOutput),
4070
+ ...contents,
4071
+ });
4072
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
5836
4073
  };
5837
4074
  const deserializeAws_restJson1ServiceFailureExceptionResponse = async (parsedOutput, context) => {
5838
- const contents = {
5839
- name: "ServiceFailureException",
5840
- $fault: "server",
5841
- $metadata: deserializeMetadata(parsedOutput),
5842
- Code: undefined,
5843
- Message: undefined,
5844
- };
4075
+ const contents = {};
5845
4076
  const data = parsedOutput.body;
5846
4077
  if (data.Code !== undefined && data.Code !== null) {
5847
4078
  contents.Code = smithy_client_1.expectString(data.Code);
@@ -5849,16 +4080,14 @@ const deserializeAws_restJson1ServiceFailureExceptionResponse = async (parsedOut
5849
4080
  if (data.Message !== undefined && data.Message !== null) {
5850
4081
  contents.Message = smithy_client_1.expectString(data.Message);
5851
4082
  }
5852
- return contents;
4083
+ const exception = new models_0_1.ServiceFailureException({
4084
+ $metadata: deserializeMetadata(parsedOutput),
4085
+ ...contents,
4086
+ });
4087
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
5853
4088
  };
5854
4089
  const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parsedOutput, context) => {
5855
- const contents = {
5856
- name: "ServiceUnavailableException",
5857
- $fault: "server",
5858
- $metadata: deserializeMetadata(parsedOutput),
5859
- Code: undefined,
5860
- Message: undefined,
5861
- };
4090
+ const contents = {};
5862
4091
  const data = parsedOutput.body;
5863
4092
  if (data.Code !== undefined && data.Code !== null) {
5864
4093
  contents.Code = smithy_client_1.expectString(data.Code);
@@ -5866,16 +4095,14 @@ const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parse
5866
4095
  if (data.Message !== undefined && data.Message !== null) {
5867
4096
  contents.Message = smithy_client_1.expectString(data.Message);
5868
4097
  }
5869
- return contents;
4098
+ const exception = new models_0_1.ServiceUnavailableException({
4099
+ $metadata: deserializeMetadata(parsedOutput),
4100
+ ...contents,
4101
+ });
4102
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
5870
4103
  };
5871
4104
  const deserializeAws_restJson1ThrottledClientExceptionResponse = async (parsedOutput, context) => {
5872
- const contents = {
5873
- name: "ThrottledClientException",
5874
- $fault: "client",
5875
- $metadata: deserializeMetadata(parsedOutput),
5876
- Code: undefined,
5877
- Message: undefined,
5878
- };
4105
+ const contents = {};
5879
4106
  const data = parsedOutput.body;
5880
4107
  if (data.Code !== undefined && data.Code !== null) {
5881
4108
  contents.Code = smithy_client_1.expectString(data.Code);
@@ -5883,16 +4110,14 @@ const deserializeAws_restJson1ThrottledClientExceptionResponse = async (parsedOu
5883
4110
  if (data.Message !== undefined && data.Message !== null) {
5884
4111
  contents.Message = smithy_client_1.expectString(data.Message);
5885
4112
  }
5886
- return contents;
4113
+ const exception = new models_0_1.ThrottledClientException({
4114
+ $metadata: deserializeMetadata(parsedOutput),
4115
+ ...contents,
4116
+ });
4117
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
5887
4118
  };
5888
4119
  const deserializeAws_restJson1UnauthorizedClientExceptionResponse = async (parsedOutput, context) => {
5889
- const contents = {
5890
- name: "UnauthorizedClientException",
5891
- $fault: "client",
5892
- $metadata: deserializeMetadata(parsedOutput),
5893
- Code: undefined,
5894
- Message: undefined,
5895
- };
4120
+ const contents = {};
5896
4121
  const data = parsedOutput.body;
5897
4122
  if (data.Code !== undefined && data.Code !== null) {
5898
4123
  contents.Code = smithy_client_1.expectString(data.Code);
@@ -5900,7 +4125,11 @@ const deserializeAws_restJson1UnauthorizedClientExceptionResponse = async (parse
5900
4125
  if (data.Message !== undefined && data.Message !== null) {
5901
4126
  contents.Message = smithy_client_1.expectString(data.Message);
5902
4127
  }
5903
- return contents;
4128
+ const exception = new models_0_1.UnauthorizedClientException({
4129
+ $metadata: deserializeMetadata(parsedOutput),
4130
+ ...contents,
4131
+ });
4132
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
5904
4133
  };
5905
4134
  const serializeAws_restJson1ChannelMembershipPreferences = (input, context) => {
5906
4135
  return {
@@ -6068,7 +4297,7 @@ const deserializeAws_restJson1BatchCreateChannelMembershipError = (output, conte
6068
4297
  };
6069
4298
  };
6070
4299
  const deserializeAws_restJson1BatchCreateChannelMembershipErrors = (output, context) => {
6071
- return (output || [])
4300
+ const retVal = (output || [])
6072
4301
  .filter((e) => e != null)
6073
4302
  .map((entry) => {
6074
4303
  if (entry === null) {
@@ -6076,6 +4305,7 @@ const deserializeAws_restJson1BatchCreateChannelMembershipErrors = (output, cont
6076
4305
  }
6077
4306
  return deserializeAws_restJson1BatchCreateChannelMembershipError(entry, context);
6078
4307
  });
4308
+ return retVal;
6079
4309
  };
6080
4310
  const deserializeAws_restJson1Channel = (output, context) => {
6081
4311
  return {
@@ -6109,7 +4339,7 @@ const deserializeAws_restJson1ChannelAssociatedWithFlowSummary = (output, contex
6109
4339
  };
6110
4340
  };
6111
4341
  const deserializeAws_restJson1ChannelAssociatedWithFlowSummaryList = (output, context) => {
6112
- return (output || [])
4342
+ const retVal = (output || [])
6113
4343
  .filter((e) => e != null)
6114
4344
  .map((entry) => {
6115
4345
  if (entry === null) {
@@ -6117,6 +4347,7 @@ const deserializeAws_restJson1ChannelAssociatedWithFlowSummaryList = (output, co
6117
4347
  }
6118
4348
  return deserializeAws_restJson1ChannelAssociatedWithFlowSummary(entry, context);
6119
4349
  });
4350
+ return retVal;
6120
4351
  };
6121
4352
  const deserializeAws_restJson1ChannelBan = (output, context) => {
6122
4353
  return {
@@ -6140,7 +4371,7 @@ const deserializeAws_restJson1ChannelBanSummary = (output, context) => {
6140
4371
  };
6141
4372
  };
6142
4373
  const deserializeAws_restJson1ChannelBanSummaryList = (output, context) => {
6143
- return (output || [])
4374
+ const retVal = (output || [])
6144
4375
  .filter((e) => e != null)
6145
4376
  .map((entry) => {
6146
4377
  if (entry === null) {
@@ -6148,6 +4379,7 @@ const deserializeAws_restJson1ChannelBanSummaryList = (output, context) => {
6148
4379
  }
6149
4380
  return deserializeAws_restJson1ChannelBanSummary(entry, context);
6150
4381
  });
4382
+ return retVal;
6151
4383
  };
6152
4384
  const deserializeAws_restJson1ChannelFlow = (output, context) => {
6153
4385
  return {
@@ -6174,7 +4406,7 @@ const deserializeAws_restJson1ChannelFlowSummary = (output, context) => {
6174
4406
  };
6175
4407
  };
6176
4408
  const deserializeAws_restJson1ChannelFlowSummaryList = (output, context) => {
6177
- return (output || [])
4409
+ const retVal = (output || [])
6178
4410
  .filter((e) => e != null)
6179
4411
  .map((entry) => {
6180
4412
  if (entry === null) {
@@ -6182,6 +4414,7 @@ const deserializeAws_restJson1ChannelFlowSummaryList = (output, context) => {
6182
4414
  }
6183
4415
  return deserializeAws_restJson1ChannelFlowSummary(entry, context);
6184
4416
  });
4417
+ return retVal;
6185
4418
  };
6186
4419
  const deserializeAws_restJson1ChannelMembership = (output, context) => {
6187
4420
  return {
@@ -6212,7 +4445,7 @@ const deserializeAws_restJson1ChannelMembershipForAppInstanceUserSummary = (outp
6212
4445
  };
6213
4446
  };
6214
4447
  const deserializeAws_restJson1ChannelMembershipForAppInstanceUserSummaryList = (output, context) => {
6215
- return (output || [])
4448
+ const retVal = (output || [])
6216
4449
  .filter((e) => e != null)
6217
4450
  .map((entry) => {
6218
4451
  if (entry === null) {
@@ -6220,6 +4453,7 @@ const deserializeAws_restJson1ChannelMembershipForAppInstanceUserSummaryList = (
6220
4453
  }
6221
4454
  return deserializeAws_restJson1ChannelMembershipForAppInstanceUserSummary(entry, context);
6222
4455
  });
4456
+ return retVal;
6223
4457
  };
6224
4458
  const deserializeAws_restJson1ChannelMembershipPreferences = (output, context) => {
6225
4459
  return {
@@ -6236,7 +4470,7 @@ const deserializeAws_restJson1ChannelMembershipSummary = (output, context) => {
6236
4470
  };
6237
4471
  };
6238
4472
  const deserializeAws_restJson1ChannelMembershipSummaryList = (output, context) => {
6239
- return (output || [])
4473
+ const retVal = (output || [])
6240
4474
  .filter((e) => e != null)
6241
4475
  .map((entry) => {
6242
4476
  if (entry === null) {
@@ -6244,6 +4478,7 @@ const deserializeAws_restJson1ChannelMembershipSummaryList = (output, context) =
6244
4478
  }
6245
4479
  return deserializeAws_restJson1ChannelMembershipSummary(entry, context);
6246
4480
  });
4481
+ return retVal;
6247
4482
  };
6248
4483
  const deserializeAws_restJson1ChannelMessage = (output, context) => {
6249
4484
  return {
@@ -6308,7 +4543,7 @@ const deserializeAws_restJson1ChannelMessageSummary = (output, context) => {
6308
4543
  };
6309
4544
  };
6310
4545
  const deserializeAws_restJson1ChannelMessageSummaryList = (output, context) => {
6311
- return (output || [])
4546
+ const retVal = (output || [])
6312
4547
  .filter((e) => e != null)
6313
4548
  .map((entry) => {
6314
4549
  if (entry === null) {
@@ -6316,6 +4551,7 @@ const deserializeAws_restJson1ChannelMessageSummaryList = (output, context) => {
6316
4551
  }
6317
4552
  return deserializeAws_restJson1ChannelMessageSummary(entry, context);
6318
4553
  });
4554
+ return retVal;
6319
4555
  };
6320
4556
  const deserializeAws_restJson1ChannelModeratedByAppInstanceUserSummary = (output, context) => {
6321
4557
  return {
@@ -6325,7 +4561,7 @@ const deserializeAws_restJson1ChannelModeratedByAppInstanceUserSummary = (output
6325
4561
  };
6326
4562
  };
6327
4563
  const deserializeAws_restJson1ChannelModeratedByAppInstanceUserSummaryList = (output, context) => {
6328
- return (output || [])
4564
+ const retVal = (output || [])
6329
4565
  .filter((e) => e != null)
6330
4566
  .map((entry) => {
6331
4567
  if (entry === null) {
@@ -6333,6 +4569,7 @@ const deserializeAws_restJson1ChannelModeratedByAppInstanceUserSummaryList = (ou
6333
4569
  }
6334
4570
  return deserializeAws_restJson1ChannelModeratedByAppInstanceUserSummary(entry, context);
6335
4571
  });
4572
+ return retVal;
6336
4573
  };
6337
4574
  const deserializeAws_restJson1ChannelModerator = (output, context) => {
6338
4575
  return {
@@ -6356,7 +4593,7 @@ const deserializeAws_restJson1ChannelModeratorSummary = (output, context) => {
6356
4593
  };
6357
4594
  };
6358
4595
  const deserializeAws_restJson1ChannelModeratorSummaryList = (output, context) => {
6359
- return (output || [])
4596
+ const retVal = (output || [])
6360
4597
  .filter((e) => e != null)
6361
4598
  .map((entry) => {
6362
4599
  if (entry === null) {
@@ -6364,6 +4601,7 @@ const deserializeAws_restJson1ChannelModeratorSummaryList = (output, context) =>
6364
4601
  }
6365
4602
  return deserializeAws_restJson1ChannelModeratorSummary(entry, context);
6366
4603
  });
4604
+ return retVal;
6367
4605
  };
6368
4606
  const deserializeAws_restJson1ChannelSummary = (output, context) => {
6369
4607
  return {
@@ -6378,7 +4616,7 @@ const deserializeAws_restJson1ChannelSummary = (output, context) => {
6378
4616
  };
6379
4617
  };
6380
4618
  const deserializeAws_restJson1ChannelSummaryList = (output, context) => {
6381
- return (output || [])
4619
+ const retVal = (output || [])
6382
4620
  .filter((e) => e != null)
6383
4621
  .map((entry) => {
6384
4622
  if (entry === null) {
@@ -6386,6 +4624,7 @@ const deserializeAws_restJson1ChannelSummaryList = (output, context) => {
6386
4624
  }
6387
4625
  return deserializeAws_restJson1ChannelSummary(entry, context);
6388
4626
  });
4627
+ return retVal;
6389
4628
  };
6390
4629
  const deserializeAws_restJson1Identity = (output, context) => {
6391
4630
  return {
@@ -6400,7 +4639,7 @@ const deserializeAws_restJson1LambdaConfiguration = (output, context) => {
6400
4639
  };
6401
4640
  };
6402
4641
  const deserializeAws_restJson1Members = (output, context) => {
6403
- return (output || [])
4642
+ const retVal = (output || [])
6404
4643
  .filter((e) => e != null)
6405
4644
  .map((entry) => {
6406
4645
  if (entry === null) {
@@ -6408,6 +4647,7 @@ const deserializeAws_restJson1Members = (output, context) => {
6408
4647
  }
6409
4648
  return deserializeAws_restJson1Identity(entry, context);
6410
4649
  });
4650
+ return retVal;
6411
4651
  };
6412
4652
  const deserializeAws_restJson1MessageAttributeMap = (output, context) => {
6413
4653
  return Object.entries(output).reduce((acc, [key, value]) => {
@@ -6421,7 +4661,7 @@ const deserializeAws_restJson1MessageAttributeMap = (output, context) => {
6421
4661
  }, {});
6422
4662
  };
6423
4663
  const deserializeAws_restJson1MessageAttributeStringValues = (output, context) => {
6424
- return (output || [])
4664
+ const retVal = (output || [])
6425
4665
  .filter((e) => e != null)
6426
4666
  .map((entry) => {
6427
4667
  if (entry === null) {
@@ -6429,6 +4669,7 @@ const deserializeAws_restJson1MessageAttributeStringValues = (output, context) =
6429
4669
  }
6430
4670
  return smithy_client_1.expectString(entry);
6431
4671
  });
4672
+ return retVal;
6432
4673
  };
6433
4674
  const deserializeAws_restJson1MessageAttributeValue = (output, context) => {
6434
4675
  return {
@@ -6460,7 +4701,7 @@ const deserializeAws_restJson1ProcessorConfiguration = (output, context) => {
6460
4701
  };
6461
4702
  };
6462
4703
  const deserializeAws_restJson1ProcessorList = (output, context) => {
6463
- return (output || [])
4704
+ const retVal = (output || [])
6464
4705
  .filter((e) => e != null)
6465
4706
  .map((entry) => {
6466
4707
  if (entry === null) {
@@ -6468,6 +4709,7 @@ const deserializeAws_restJson1ProcessorList = (output, context) => {
6468
4709
  }
6469
4710
  return deserializeAws_restJson1Processor(entry, context);
6470
4711
  });
4712
+ return retVal;
6471
4713
  };
6472
4714
  const deserializeAws_restJson1PushNotificationPreferences = (output, context) => {
6473
4715
  return {
@@ -6482,7 +4724,7 @@ const deserializeAws_restJson1Tag = (output, context) => {
6482
4724
  };
6483
4725
  };
6484
4726
  const deserializeAws_restJson1TagList = (output, context) => {
6485
- return (output || [])
4727
+ const retVal = (output || [])
6486
4728
  .filter((e) => e != null)
6487
4729
  .map((entry) => {
6488
4730
  if (entry === null) {
@@ -6490,6 +4732,7 @@ const deserializeAws_restJson1TagList = (output, context) => {
6490
4732
  }
6491
4733
  return deserializeAws_restJson1Tag(entry, context);
6492
4734
  });
4735
+ return retVal;
6493
4736
  };
6494
4737
  const deserializeMetadata = (output) => {
6495
4738
  var _a;