@aws-sdk/client-guardduty 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.
- package/CHANGELOG.md +11 -0
- package/dist-cjs/index.js +3 -0
- package/dist-cjs/models/GuardDutyServiceException.js +11 -0
- package/dist-cjs/models/models_0.js +36 -5
- package/dist-cjs/protocols/Aws_restJson1.js +430 -1326
- package/dist-es/index.js +1 -0
- package/dist-es/models/GuardDutyServiceException.js +12 -0
- package/dist-es/models/models_0.js +30 -1
- package/dist-es/protocols/Aws_restJson1.js +1007 -1561
- package/dist-types/index.d.ts +1 -0
- package/dist-types/models/GuardDutyServiceException.d.ts +10 -0
- package/dist-types/models/models_0.d.ts +16 -7
- package/dist-types/ts3.4/index.d.ts +1 -0
- package/dist-types/ts3.4/models/GuardDutyServiceException.d.ts +6 -0
- package/dist-types/ts3.4/models/models_0.d.ts +12 -7
- package/package.json +25 -25
|
@@ -6,6 +6,8 @@ exports.deserializeAws_restJson1UpdateThreatIntelSetCommand = exports.deserializ
|
|
|
6
6
|
const protocol_http_1 = require("@aws-sdk/protocol-http");
|
|
7
7
|
const smithy_client_1 = require("@aws-sdk/smithy-client");
|
|
8
8
|
const uuid_1 = require("uuid");
|
|
9
|
+
const GuardDutyServiceException_1 = require("../models/GuardDutyServiceException");
|
|
10
|
+
const models_0_1 = require("../models/models_0");
|
|
9
11
|
const serializeAws_restJson1AcceptInvitationCommand = async (input, context) => {
|
|
10
12
|
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
|
|
11
13
|
const headers = {
|
|
@@ -1915,35 +1917,19 @@ const deserializeAws_restJson1AcceptInvitationCommandError = async (output, cont
|
|
|
1915
1917
|
switch (errorCode) {
|
|
1916
1918
|
case "BadRequestException":
|
|
1917
1919
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
1918
|
-
|
|
1919
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
1920
|
-
name: errorCode,
|
|
1921
|
-
$metadata: deserializeMetadata(output),
|
|
1922
|
-
};
|
|
1923
|
-
break;
|
|
1920
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
1924
1921
|
case "InternalServerErrorException":
|
|
1925
1922
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
1926
|
-
|
|
1927
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
1928
|
-
name: errorCode,
|
|
1929
|
-
$metadata: deserializeMetadata(output),
|
|
1930
|
-
};
|
|
1931
|
-
break;
|
|
1923
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
1932
1924
|
default:
|
|
1933
1925
|
const parsedBody = parsedOutput.body;
|
|
1934
|
-
|
|
1935
|
-
|
|
1936
|
-
...parsedBody,
|
|
1937
|
-
name: `${errorCode}`,
|
|
1938
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1926
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
1927
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1939
1928
|
$fault: "client",
|
|
1940
1929
|
$metadata: deserializeMetadata(output),
|
|
1941
|
-
};
|
|
1930
|
+
});
|
|
1931
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1942
1932
|
}
|
|
1943
|
-
const message = response.message || response.Message || errorCode;
|
|
1944
|
-
response.message = message;
|
|
1945
|
-
delete response.Message;
|
|
1946
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1947
1933
|
};
|
|
1948
1934
|
const deserializeAws_restJson1ArchiveFindingsCommand = async (output, context) => {
|
|
1949
1935
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -1967,35 +1953,19 @@ const deserializeAws_restJson1ArchiveFindingsCommandError = async (output, conte
|
|
|
1967
1953
|
switch (errorCode) {
|
|
1968
1954
|
case "BadRequestException":
|
|
1969
1955
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
1970
|
-
|
|
1971
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
1972
|
-
name: errorCode,
|
|
1973
|
-
$metadata: deserializeMetadata(output),
|
|
1974
|
-
};
|
|
1975
|
-
break;
|
|
1956
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
1976
1957
|
case "InternalServerErrorException":
|
|
1977
1958
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
1978
|
-
|
|
1979
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
1980
|
-
name: errorCode,
|
|
1981
|
-
$metadata: deserializeMetadata(output),
|
|
1982
|
-
};
|
|
1983
|
-
break;
|
|
1959
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
1984
1960
|
default:
|
|
1985
1961
|
const parsedBody = parsedOutput.body;
|
|
1986
|
-
|
|
1987
|
-
|
|
1988
|
-
...parsedBody,
|
|
1989
|
-
name: `${errorCode}`,
|
|
1990
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1962
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
1963
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1991
1964
|
$fault: "client",
|
|
1992
1965
|
$metadata: deserializeMetadata(output),
|
|
1993
|
-
};
|
|
1966
|
+
});
|
|
1967
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1994
1968
|
}
|
|
1995
|
-
const message = response.message || response.Message || errorCode;
|
|
1996
|
-
response.message = message;
|
|
1997
|
-
delete response.Message;
|
|
1998
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1999
1969
|
};
|
|
2000
1970
|
const deserializeAws_restJson1CreateDetectorCommand = async (output, context) => {
|
|
2001
1971
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2023,35 +1993,19 @@ const deserializeAws_restJson1CreateDetectorCommandError = async (output, contex
|
|
|
2023
1993
|
switch (errorCode) {
|
|
2024
1994
|
case "BadRequestException":
|
|
2025
1995
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2026
|
-
|
|
2027
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2028
|
-
name: errorCode,
|
|
2029
|
-
$metadata: deserializeMetadata(output),
|
|
2030
|
-
};
|
|
2031
|
-
break;
|
|
1996
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2032
1997
|
case "InternalServerErrorException":
|
|
2033
1998
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2034
|
-
|
|
2035
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2036
|
-
name: errorCode,
|
|
2037
|
-
$metadata: deserializeMetadata(output),
|
|
2038
|
-
};
|
|
2039
|
-
break;
|
|
1999
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2040
2000
|
default:
|
|
2041
2001
|
const parsedBody = parsedOutput.body;
|
|
2042
|
-
|
|
2043
|
-
|
|
2044
|
-
...parsedBody,
|
|
2045
|
-
name: `${errorCode}`,
|
|
2046
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2002
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2003
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2047
2004
|
$fault: "client",
|
|
2048
2005
|
$metadata: deserializeMetadata(output),
|
|
2049
|
-
};
|
|
2006
|
+
});
|
|
2007
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2050
2008
|
}
|
|
2051
|
-
const message = response.message || response.Message || errorCode;
|
|
2052
|
-
response.message = message;
|
|
2053
|
-
delete response.Message;
|
|
2054
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2055
2009
|
};
|
|
2056
2010
|
const deserializeAws_restJson1CreateFilterCommand = async (output, context) => {
|
|
2057
2011
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2079,35 +2033,19 @@ const deserializeAws_restJson1CreateFilterCommandError = async (output, context)
|
|
|
2079
2033
|
switch (errorCode) {
|
|
2080
2034
|
case "BadRequestException":
|
|
2081
2035
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2082
|
-
|
|
2083
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2084
|
-
name: errorCode,
|
|
2085
|
-
$metadata: deserializeMetadata(output),
|
|
2086
|
-
};
|
|
2087
|
-
break;
|
|
2036
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2088
2037
|
case "InternalServerErrorException":
|
|
2089
2038
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2090
|
-
|
|
2091
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2092
|
-
name: errorCode,
|
|
2093
|
-
$metadata: deserializeMetadata(output),
|
|
2094
|
-
};
|
|
2095
|
-
break;
|
|
2039
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2096
2040
|
default:
|
|
2097
2041
|
const parsedBody = parsedOutput.body;
|
|
2098
|
-
|
|
2099
|
-
|
|
2100
|
-
...parsedBody,
|
|
2101
|
-
name: `${errorCode}`,
|
|
2102
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2042
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2043
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2103
2044
|
$fault: "client",
|
|
2104
2045
|
$metadata: deserializeMetadata(output),
|
|
2105
|
-
};
|
|
2046
|
+
});
|
|
2047
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2106
2048
|
}
|
|
2107
|
-
const message = response.message || response.Message || errorCode;
|
|
2108
|
-
response.message = message;
|
|
2109
|
-
delete response.Message;
|
|
2110
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2111
2049
|
};
|
|
2112
2050
|
const deserializeAws_restJson1CreateIPSetCommand = async (output, context) => {
|
|
2113
2051
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2135,35 +2073,19 @@ const deserializeAws_restJson1CreateIPSetCommandError = async (output, context)
|
|
|
2135
2073
|
switch (errorCode) {
|
|
2136
2074
|
case "BadRequestException":
|
|
2137
2075
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2138
|
-
|
|
2139
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2140
|
-
name: errorCode,
|
|
2141
|
-
$metadata: deserializeMetadata(output),
|
|
2142
|
-
};
|
|
2143
|
-
break;
|
|
2076
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2144
2077
|
case "InternalServerErrorException":
|
|
2145
2078
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2146
|
-
|
|
2147
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2148
|
-
name: errorCode,
|
|
2149
|
-
$metadata: deserializeMetadata(output),
|
|
2150
|
-
};
|
|
2151
|
-
break;
|
|
2079
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2152
2080
|
default:
|
|
2153
2081
|
const parsedBody = parsedOutput.body;
|
|
2154
|
-
|
|
2155
|
-
|
|
2156
|
-
...parsedBody,
|
|
2157
|
-
name: `${errorCode}`,
|
|
2158
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2082
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2083
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2159
2084
|
$fault: "client",
|
|
2160
2085
|
$metadata: deserializeMetadata(output),
|
|
2161
|
-
};
|
|
2086
|
+
});
|
|
2087
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2162
2088
|
}
|
|
2163
|
-
const message = response.message || response.Message || errorCode;
|
|
2164
|
-
response.message = message;
|
|
2165
|
-
delete response.Message;
|
|
2166
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2167
2089
|
};
|
|
2168
2090
|
const deserializeAws_restJson1CreateMembersCommand = async (output, context) => {
|
|
2169
2091
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2191,35 +2113,19 @@ const deserializeAws_restJson1CreateMembersCommandError = async (output, context
|
|
|
2191
2113
|
switch (errorCode) {
|
|
2192
2114
|
case "BadRequestException":
|
|
2193
2115
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2194
|
-
|
|
2195
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2196
|
-
name: errorCode,
|
|
2197
|
-
$metadata: deserializeMetadata(output),
|
|
2198
|
-
};
|
|
2199
|
-
break;
|
|
2116
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2200
2117
|
case "InternalServerErrorException":
|
|
2201
2118
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2202
|
-
|
|
2203
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2204
|
-
name: errorCode,
|
|
2205
|
-
$metadata: deserializeMetadata(output),
|
|
2206
|
-
};
|
|
2207
|
-
break;
|
|
2119
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2208
2120
|
default:
|
|
2209
2121
|
const parsedBody = parsedOutput.body;
|
|
2210
|
-
|
|
2211
|
-
|
|
2212
|
-
...parsedBody,
|
|
2213
|
-
name: `${errorCode}`,
|
|
2214
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2122
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2123
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2215
2124
|
$fault: "client",
|
|
2216
2125
|
$metadata: deserializeMetadata(output),
|
|
2217
|
-
};
|
|
2126
|
+
});
|
|
2127
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2218
2128
|
}
|
|
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
2129
|
};
|
|
2224
2130
|
const deserializeAws_restJson1CreatePublishingDestinationCommand = async (output, context) => {
|
|
2225
2131
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2247,35 +2153,19 @@ const deserializeAws_restJson1CreatePublishingDestinationCommandError = async (o
|
|
|
2247
2153
|
switch (errorCode) {
|
|
2248
2154
|
case "BadRequestException":
|
|
2249
2155
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2250
|
-
|
|
2251
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2252
|
-
name: errorCode,
|
|
2253
|
-
$metadata: deserializeMetadata(output),
|
|
2254
|
-
};
|
|
2255
|
-
break;
|
|
2156
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2256
2157
|
case "InternalServerErrorException":
|
|
2257
2158
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2258
|
-
|
|
2259
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2260
|
-
name: errorCode,
|
|
2261
|
-
$metadata: deserializeMetadata(output),
|
|
2262
|
-
};
|
|
2263
|
-
break;
|
|
2159
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2264
2160
|
default:
|
|
2265
2161
|
const parsedBody = parsedOutput.body;
|
|
2266
|
-
|
|
2267
|
-
|
|
2268
|
-
...parsedBody,
|
|
2269
|
-
name: `${errorCode}`,
|
|
2270
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2162
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2163
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2271
2164
|
$fault: "client",
|
|
2272
2165
|
$metadata: deserializeMetadata(output),
|
|
2273
|
-
};
|
|
2166
|
+
});
|
|
2167
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2274
2168
|
}
|
|
2275
|
-
const message = response.message || response.Message || errorCode;
|
|
2276
|
-
response.message = message;
|
|
2277
|
-
delete response.Message;
|
|
2278
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2279
2169
|
};
|
|
2280
2170
|
const deserializeAws_restJson1CreateSampleFindingsCommand = async (output, context) => {
|
|
2281
2171
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2299,35 +2189,19 @@ const deserializeAws_restJson1CreateSampleFindingsCommandError = async (output,
|
|
|
2299
2189
|
switch (errorCode) {
|
|
2300
2190
|
case "BadRequestException":
|
|
2301
2191
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2302
|
-
|
|
2303
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2304
|
-
name: errorCode,
|
|
2305
|
-
$metadata: deserializeMetadata(output),
|
|
2306
|
-
};
|
|
2307
|
-
break;
|
|
2192
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2308
2193
|
case "InternalServerErrorException":
|
|
2309
2194
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2310
|
-
|
|
2311
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2312
|
-
name: errorCode,
|
|
2313
|
-
$metadata: deserializeMetadata(output),
|
|
2314
|
-
};
|
|
2315
|
-
break;
|
|
2195
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2316
2196
|
default:
|
|
2317
2197
|
const parsedBody = parsedOutput.body;
|
|
2318
|
-
|
|
2319
|
-
|
|
2320
|
-
...parsedBody,
|
|
2321
|
-
name: `${errorCode}`,
|
|
2322
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2198
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2199
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2323
2200
|
$fault: "client",
|
|
2324
2201
|
$metadata: deserializeMetadata(output),
|
|
2325
|
-
};
|
|
2202
|
+
});
|
|
2203
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2326
2204
|
}
|
|
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
2205
|
};
|
|
2332
2206
|
const deserializeAws_restJson1CreateThreatIntelSetCommand = async (output, context) => {
|
|
2333
2207
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2355,35 +2229,19 @@ const deserializeAws_restJson1CreateThreatIntelSetCommandError = async (output,
|
|
|
2355
2229
|
switch (errorCode) {
|
|
2356
2230
|
case "BadRequestException":
|
|
2357
2231
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2358
|
-
|
|
2359
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2360
|
-
name: errorCode,
|
|
2361
|
-
$metadata: deserializeMetadata(output),
|
|
2362
|
-
};
|
|
2363
|
-
break;
|
|
2232
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2364
2233
|
case "InternalServerErrorException":
|
|
2365
2234
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2366
|
-
|
|
2367
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2368
|
-
name: errorCode,
|
|
2369
|
-
$metadata: deserializeMetadata(output),
|
|
2370
|
-
};
|
|
2371
|
-
break;
|
|
2235
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2372
2236
|
default:
|
|
2373
2237
|
const parsedBody = parsedOutput.body;
|
|
2374
|
-
|
|
2375
|
-
|
|
2376
|
-
...parsedBody,
|
|
2377
|
-
name: `${errorCode}`,
|
|
2378
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2238
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2239
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2379
2240
|
$fault: "client",
|
|
2380
2241
|
$metadata: deserializeMetadata(output),
|
|
2381
|
-
};
|
|
2242
|
+
});
|
|
2243
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2382
2244
|
}
|
|
2383
|
-
const message = response.message || response.Message || errorCode;
|
|
2384
|
-
response.message = message;
|
|
2385
|
-
delete response.Message;
|
|
2386
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2387
2245
|
};
|
|
2388
2246
|
const deserializeAws_restJson1DeclineInvitationsCommand = async (output, context) => {
|
|
2389
2247
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2411,35 +2269,19 @@ const deserializeAws_restJson1DeclineInvitationsCommandError = async (output, co
|
|
|
2411
2269
|
switch (errorCode) {
|
|
2412
2270
|
case "BadRequestException":
|
|
2413
2271
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2414
|
-
|
|
2415
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2416
|
-
name: errorCode,
|
|
2417
|
-
$metadata: deserializeMetadata(output),
|
|
2418
|
-
};
|
|
2419
|
-
break;
|
|
2272
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2420
2273
|
case "InternalServerErrorException":
|
|
2421
2274
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2422
|
-
|
|
2423
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2424
|
-
name: errorCode,
|
|
2425
|
-
$metadata: deserializeMetadata(output),
|
|
2426
|
-
};
|
|
2427
|
-
break;
|
|
2275
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2428
2276
|
default:
|
|
2429
2277
|
const parsedBody = parsedOutput.body;
|
|
2430
|
-
|
|
2431
|
-
|
|
2432
|
-
...parsedBody,
|
|
2433
|
-
name: `${errorCode}`,
|
|
2434
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2278
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2279
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2435
2280
|
$fault: "client",
|
|
2436
2281
|
$metadata: deserializeMetadata(output),
|
|
2437
|
-
};
|
|
2282
|
+
});
|
|
2283
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2438
2284
|
}
|
|
2439
|
-
const message = response.message || response.Message || errorCode;
|
|
2440
|
-
response.message = message;
|
|
2441
|
-
delete response.Message;
|
|
2442
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2443
2285
|
};
|
|
2444
2286
|
const deserializeAws_restJson1DeleteDetectorCommand = async (output, context) => {
|
|
2445
2287
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2463,35 +2305,19 @@ const deserializeAws_restJson1DeleteDetectorCommandError = async (output, contex
|
|
|
2463
2305
|
switch (errorCode) {
|
|
2464
2306
|
case "BadRequestException":
|
|
2465
2307
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2466
|
-
|
|
2467
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2468
|
-
name: errorCode,
|
|
2469
|
-
$metadata: deserializeMetadata(output),
|
|
2470
|
-
};
|
|
2471
|
-
break;
|
|
2308
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2472
2309
|
case "InternalServerErrorException":
|
|
2473
2310
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2474
|
-
|
|
2475
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2476
|
-
name: errorCode,
|
|
2477
|
-
$metadata: deserializeMetadata(output),
|
|
2478
|
-
};
|
|
2479
|
-
break;
|
|
2311
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2480
2312
|
default:
|
|
2481
2313
|
const parsedBody = parsedOutput.body;
|
|
2482
|
-
|
|
2483
|
-
|
|
2484
|
-
...parsedBody,
|
|
2485
|
-
name: `${errorCode}`,
|
|
2486
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2314
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2315
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2487
2316
|
$fault: "client",
|
|
2488
2317
|
$metadata: deserializeMetadata(output),
|
|
2489
|
-
};
|
|
2318
|
+
});
|
|
2319
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2490
2320
|
}
|
|
2491
|
-
const message = response.message || response.Message || errorCode;
|
|
2492
|
-
response.message = message;
|
|
2493
|
-
delete response.Message;
|
|
2494
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2495
2321
|
};
|
|
2496
2322
|
const deserializeAws_restJson1DeleteFilterCommand = async (output, context) => {
|
|
2497
2323
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2515,35 +2341,19 @@ const deserializeAws_restJson1DeleteFilterCommandError = async (output, context)
|
|
|
2515
2341
|
switch (errorCode) {
|
|
2516
2342
|
case "BadRequestException":
|
|
2517
2343
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2518
|
-
|
|
2519
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2520
|
-
name: errorCode,
|
|
2521
|
-
$metadata: deserializeMetadata(output),
|
|
2522
|
-
};
|
|
2523
|
-
break;
|
|
2344
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2524
2345
|
case "InternalServerErrorException":
|
|
2525
2346
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2526
|
-
|
|
2527
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2528
|
-
name: errorCode,
|
|
2529
|
-
$metadata: deserializeMetadata(output),
|
|
2530
|
-
};
|
|
2531
|
-
break;
|
|
2347
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2532
2348
|
default:
|
|
2533
2349
|
const parsedBody = parsedOutput.body;
|
|
2534
|
-
|
|
2535
|
-
|
|
2536
|
-
...parsedBody,
|
|
2537
|
-
name: `${errorCode}`,
|
|
2538
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2350
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2351
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2539
2352
|
$fault: "client",
|
|
2540
2353
|
$metadata: deserializeMetadata(output),
|
|
2541
|
-
};
|
|
2354
|
+
});
|
|
2355
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2542
2356
|
}
|
|
2543
|
-
const message = response.message || response.Message || errorCode;
|
|
2544
|
-
response.message = message;
|
|
2545
|
-
delete response.Message;
|
|
2546
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2547
2357
|
};
|
|
2548
2358
|
const deserializeAws_restJson1DeleteInvitationsCommand = async (output, context) => {
|
|
2549
2359
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2571,35 +2381,19 @@ const deserializeAws_restJson1DeleteInvitationsCommandError = async (output, con
|
|
|
2571
2381
|
switch (errorCode) {
|
|
2572
2382
|
case "BadRequestException":
|
|
2573
2383
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2574
|
-
|
|
2575
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2576
|
-
name: errorCode,
|
|
2577
|
-
$metadata: deserializeMetadata(output),
|
|
2578
|
-
};
|
|
2579
|
-
break;
|
|
2384
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2580
2385
|
case "InternalServerErrorException":
|
|
2581
2386
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2582
|
-
|
|
2583
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2584
|
-
name: errorCode,
|
|
2585
|
-
$metadata: deserializeMetadata(output),
|
|
2586
|
-
};
|
|
2587
|
-
break;
|
|
2387
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2588
2388
|
default:
|
|
2589
2389
|
const parsedBody = parsedOutput.body;
|
|
2590
|
-
|
|
2591
|
-
|
|
2592
|
-
...parsedBody,
|
|
2593
|
-
name: `${errorCode}`,
|
|
2594
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2390
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2391
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2595
2392
|
$fault: "client",
|
|
2596
2393
|
$metadata: deserializeMetadata(output),
|
|
2597
|
-
};
|
|
2394
|
+
});
|
|
2395
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2598
2396
|
}
|
|
2599
|
-
const message = response.message || response.Message || errorCode;
|
|
2600
|
-
response.message = message;
|
|
2601
|
-
delete response.Message;
|
|
2602
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2603
2397
|
};
|
|
2604
2398
|
const deserializeAws_restJson1DeleteIPSetCommand = async (output, context) => {
|
|
2605
2399
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2623,35 +2417,19 @@ const deserializeAws_restJson1DeleteIPSetCommandError = async (output, context)
|
|
|
2623
2417
|
switch (errorCode) {
|
|
2624
2418
|
case "BadRequestException":
|
|
2625
2419
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2626
|
-
|
|
2627
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2628
|
-
name: errorCode,
|
|
2629
|
-
$metadata: deserializeMetadata(output),
|
|
2630
|
-
};
|
|
2631
|
-
break;
|
|
2420
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2632
2421
|
case "InternalServerErrorException":
|
|
2633
2422
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2634
|
-
|
|
2635
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2636
|
-
name: errorCode,
|
|
2637
|
-
$metadata: deserializeMetadata(output),
|
|
2638
|
-
};
|
|
2639
|
-
break;
|
|
2423
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2640
2424
|
default:
|
|
2641
2425
|
const parsedBody = parsedOutput.body;
|
|
2642
|
-
|
|
2643
|
-
|
|
2644
|
-
...parsedBody,
|
|
2645
|
-
name: `${errorCode}`,
|
|
2646
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2426
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2427
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2647
2428
|
$fault: "client",
|
|
2648
2429
|
$metadata: deserializeMetadata(output),
|
|
2649
|
-
};
|
|
2430
|
+
});
|
|
2431
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2650
2432
|
}
|
|
2651
|
-
const message = response.message || response.Message || errorCode;
|
|
2652
|
-
response.message = message;
|
|
2653
|
-
delete response.Message;
|
|
2654
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2655
2433
|
};
|
|
2656
2434
|
const deserializeAws_restJson1DeleteMembersCommand = async (output, context) => {
|
|
2657
2435
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2679,35 +2457,19 @@ const deserializeAws_restJson1DeleteMembersCommandError = async (output, context
|
|
|
2679
2457
|
switch (errorCode) {
|
|
2680
2458
|
case "BadRequestException":
|
|
2681
2459
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2682
|
-
|
|
2683
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2684
|
-
name: errorCode,
|
|
2685
|
-
$metadata: deserializeMetadata(output),
|
|
2686
|
-
};
|
|
2687
|
-
break;
|
|
2460
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2688
2461
|
case "InternalServerErrorException":
|
|
2689
2462
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2690
|
-
|
|
2691
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2692
|
-
name: errorCode,
|
|
2693
|
-
$metadata: deserializeMetadata(output),
|
|
2694
|
-
};
|
|
2695
|
-
break;
|
|
2463
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2696
2464
|
default:
|
|
2697
2465
|
const parsedBody = parsedOutput.body;
|
|
2698
|
-
|
|
2699
|
-
|
|
2700
|
-
...parsedBody,
|
|
2701
|
-
name: `${errorCode}`,
|
|
2702
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2466
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2467
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2703
2468
|
$fault: "client",
|
|
2704
2469
|
$metadata: deserializeMetadata(output),
|
|
2705
|
-
};
|
|
2470
|
+
});
|
|
2471
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2706
2472
|
}
|
|
2707
|
-
const message = response.message || response.Message || errorCode;
|
|
2708
|
-
response.message = message;
|
|
2709
|
-
delete response.Message;
|
|
2710
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2711
2473
|
};
|
|
2712
2474
|
const deserializeAws_restJson1DeletePublishingDestinationCommand = async (output, context) => {
|
|
2713
2475
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2731,35 +2493,19 @@ const deserializeAws_restJson1DeletePublishingDestinationCommandError = async (o
|
|
|
2731
2493
|
switch (errorCode) {
|
|
2732
2494
|
case "BadRequestException":
|
|
2733
2495
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2734
|
-
|
|
2735
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2736
|
-
name: errorCode,
|
|
2737
|
-
$metadata: deserializeMetadata(output),
|
|
2738
|
-
};
|
|
2739
|
-
break;
|
|
2496
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2740
2497
|
case "InternalServerErrorException":
|
|
2741
2498
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2742
|
-
|
|
2743
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2744
|
-
name: errorCode,
|
|
2745
|
-
$metadata: deserializeMetadata(output),
|
|
2746
|
-
};
|
|
2747
|
-
break;
|
|
2499
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2748
2500
|
default:
|
|
2749
2501
|
const parsedBody = parsedOutput.body;
|
|
2750
|
-
|
|
2751
|
-
|
|
2752
|
-
...parsedBody,
|
|
2753
|
-
name: `${errorCode}`,
|
|
2754
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2502
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2503
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2755
2504
|
$fault: "client",
|
|
2756
2505
|
$metadata: deserializeMetadata(output),
|
|
2757
|
-
};
|
|
2506
|
+
});
|
|
2507
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2758
2508
|
}
|
|
2759
|
-
const message = response.message || response.Message || errorCode;
|
|
2760
|
-
response.message = message;
|
|
2761
|
-
delete response.Message;
|
|
2762
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2763
2509
|
};
|
|
2764
2510
|
const deserializeAws_restJson1DeleteThreatIntelSetCommand = async (output, context) => {
|
|
2765
2511
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2783,35 +2529,19 @@ const deserializeAws_restJson1DeleteThreatIntelSetCommandError = async (output,
|
|
|
2783
2529
|
switch (errorCode) {
|
|
2784
2530
|
case "BadRequestException":
|
|
2785
2531
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2786
|
-
|
|
2787
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2788
|
-
name: errorCode,
|
|
2789
|
-
$metadata: deserializeMetadata(output),
|
|
2790
|
-
};
|
|
2791
|
-
break;
|
|
2532
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2792
2533
|
case "InternalServerErrorException":
|
|
2793
2534
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2794
|
-
|
|
2795
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2796
|
-
name: errorCode,
|
|
2797
|
-
$metadata: deserializeMetadata(output),
|
|
2798
|
-
};
|
|
2799
|
-
break;
|
|
2535
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2800
2536
|
default:
|
|
2801
2537
|
const parsedBody = parsedOutput.body;
|
|
2802
|
-
|
|
2803
|
-
|
|
2804
|
-
...parsedBody,
|
|
2805
|
-
name: `${errorCode}`,
|
|
2806
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2538
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2539
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2807
2540
|
$fault: "client",
|
|
2808
2541
|
$metadata: deserializeMetadata(output),
|
|
2809
|
-
};
|
|
2542
|
+
});
|
|
2543
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2810
2544
|
}
|
|
2811
|
-
const message = response.message || response.Message || errorCode;
|
|
2812
|
-
response.message = message;
|
|
2813
|
-
delete response.Message;
|
|
2814
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2815
2545
|
};
|
|
2816
2546
|
const deserializeAws_restJson1DescribeOrganizationConfigurationCommand = async (output, context) => {
|
|
2817
2547
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2847,35 +2577,19 @@ const deserializeAws_restJson1DescribeOrganizationConfigurationCommandError = as
|
|
|
2847
2577
|
switch (errorCode) {
|
|
2848
2578
|
case "BadRequestException":
|
|
2849
2579
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2850
|
-
|
|
2851
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2852
|
-
name: errorCode,
|
|
2853
|
-
$metadata: deserializeMetadata(output),
|
|
2854
|
-
};
|
|
2855
|
-
break;
|
|
2580
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2856
2581
|
case "InternalServerErrorException":
|
|
2857
2582
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2858
|
-
|
|
2859
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2860
|
-
name: errorCode,
|
|
2861
|
-
$metadata: deserializeMetadata(output),
|
|
2862
|
-
};
|
|
2863
|
-
break;
|
|
2583
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2864
2584
|
default:
|
|
2865
2585
|
const parsedBody = parsedOutput.body;
|
|
2866
|
-
|
|
2867
|
-
|
|
2868
|
-
...parsedBody,
|
|
2869
|
-
name: `${errorCode}`,
|
|
2870
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2586
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2587
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2871
2588
|
$fault: "client",
|
|
2872
2589
|
$metadata: deserializeMetadata(output),
|
|
2873
|
-
};
|
|
2590
|
+
});
|
|
2591
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2874
2592
|
}
|
|
2875
|
-
const message = response.message || response.Message || errorCode;
|
|
2876
|
-
response.message = message;
|
|
2877
|
-
delete response.Message;
|
|
2878
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2879
2593
|
};
|
|
2880
2594
|
const deserializeAws_restJson1DescribePublishingDestinationCommand = async (output, context) => {
|
|
2881
2595
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2919,35 +2633,19 @@ const deserializeAws_restJson1DescribePublishingDestinationCommandError = async
|
|
|
2919
2633
|
switch (errorCode) {
|
|
2920
2634
|
case "BadRequestException":
|
|
2921
2635
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2922
|
-
|
|
2923
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2924
|
-
name: errorCode,
|
|
2925
|
-
$metadata: deserializeMetadata(output),
|
|
2926
|
-
};
|
|
2927
|
-
break;
|
|
2636
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2928
2637
|
case "InternalServerErrorException":
|
|
2929
2638
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2930
|
-
|
|
2931
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2932
|
-
name: errorCode,
|
|
2933
|
-
$metadata: deserializeMetadata(output),
|
|
2934
|
-
};
|
|
2935
|
-
break;
|
|
2639
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2936
2640
|
default:
|
|
2937
2641
|
const parsedBody = parsedOutput.body;
|
|
2938
|
-
|
|
2939
|
-
|
|
2940
|
-
...parsedBody,
|
|
2941
|
-
name: `${errorCode}`,
|
|
2942
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2642
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2643
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2943
2644
|
$fault: "client",
|
|
2944
2645
|
$metadata: deserializeMetadata(output),
|
|
2945
|
-
};
|
|
2646
|
+
});
|
|
2647
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2946
2648
|
}
|
|
2947
|
-
const message = response.message || response.Message || errorCode;
|
|
2948
|
-
response.message = message;
|
|
2949
|
-
delete response.Message;
|
|
2950
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2951
2649
|
};
|
|
2952
2650
|
const deserializeAws_restJson1DisableOrganizationAdminAccountCommand = async (output, context) => {
|
|
2953
2651
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2971,35 +2669,19 @@ const deserializeAws_restJson1DisableOrganizationAdminAccountCommandError = asyn
|
|
|
2971
2669
|
switch (errorCode) {
|
|
2972
2670
|
case "BadRequestException":
|
|
2973
2671
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
2974
|
-
|
|
2975
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2976
|
-
name: errorCode,
|
|
2977
|
-
$metadata: deserializeMetadata(output),
|
|
2978
|
-
};
|
|
2979
|
-
break;
|
|
2672
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2980
2673
|
case "InternalServerErrorException":
|
|
2981
2674
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
2982
|
-
|
|
2983
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2984
|
-
name: errorCode,
|
|
2985
|
-
$metadata: deserializeMetadata(output),
|
|
2986
|
-
};
|
|
2987
|
-
break;
|
|
2675
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2988
2676
|
default:
|
|
2989
2677
|
const parsedBody = parsedOutput.body;
|
|
2990
|
-
|
|
2991
|
-
|
|
2992
|
-
...parsedBody,
|
|
2993
|
-
name: `${errorCode}`,
|
|
2994
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2678
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2679
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2995
2680
|
$fault: "client",
|
|
2996
2681
|
$metadata: deserializeMetadata(output),
|
|
2997
|
-
};
|
|
2682
|
+
});
|
|
2683
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2998
2684
|
}
|
|
2999
|
-
const message = response.message || response.Message || errorCode;
|
|
3000
|
-
response.message = message;
|
|
3001
|
-
delete response.Message;
|
|
3002
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3003
2685
|
};
|
|
3004
2686
|
const deserializeAws_restJson1DisassociateFromMasterAccountCommand = async (output, context) => {
|
|
3005
2687
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3023,35 +2705,19 @@ const deserializeAws_restJson1DisassociateFromMasterAccountCommandError = async
|
|
|
3023
2705
|
switch (errorCode) {
|
|
3024
2706
|
case "BadRequestException":
|
|
3025
2707
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3026
|
-
|
|
3027
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3028
|
-
name: errorCode,
|
|
3029
|
-
$metadata: deserializeMetadata(output),
|
|
3030
|
-
};
|
|
3031
|
-
break;
|
|
2708
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3032
2709
|
case "InternalServerErrorException":
|
|
3033
2710
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3034
|
-
|
|
3035
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3036
|
-
name: errorCode,
|
|
3037
|
-
$metadata: deserializeMetadata(output),
|
|
3038
|
-
};
|
|
3039
|
-
break;
|
|
2711
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3040
2712
|
default:
|
|
3041
2713
|
const parsedBody = parsedOutput.body;
|
|
3042
|
-
|
|
3043
|
-
|
|
3044
|
-
...parsedBody,
|
|
3045
|
-
name: `${errorCode}`,
|
|
3046
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2714
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2715
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3047
2716
|
$fault: "client",
|
|
3048
2717
|
$metadata: deserializeMetadata(output),
|
|
3049
|
-
};
|
|
2718
|
+
});
|
|
2719
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3050
2720
|
}
|
|
3051
|
-
const message = response.message || response.Message || errorCode;
|
|
3052
|
-
response.message = message;
|
|
3053
|
-
delete response.Message;
|
|
3054
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3055
2721
|
};
|
|
3056
2722
|
const deserializeAws_restJson1DisassociateMembersCommand = async (output, context) => {
|
|
3057
2723
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3079,35 +2745,19 @@ const deserializeAws_restJson1DisassociateMembersCommandError = async (output, c
|
|
|
3079
2745
|
switch (errorCode) {
|
|
3080
2746
|
case "BadRequestException":
|
|
3081
2747
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3082
|
-
|
|
3083
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3084
|
-
name: errorCode,
|
|
3085
|
-
$metadata: deserializeMetadata(output),
|
|
3086
|
-
};
|
|
3087
|
-
break;
|
|
2748
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3088
2749
|
case "InternalServerErrorException":
|
|
3089
2750
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3090
|
-
|
|
3091
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3092
|
-
name: errorCode,
|
|
3093
|
-
$metadata: deserializeMetadata(output),
|
|
3094
|
-
};
|
|
3095
|
-
break;
|
|
2751
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3096
2752
|
default:
|
|
3097
2753
|
const parsedBody = parsedOutput.body;
|
|
3098
|
-
|
|
3099
|
-
|
|
3100
|
-
...parsedBody,
|
|
3101
|
-
name: `${errorCode}`,
|
|
3102
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2754
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2755
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3103
2756
|
$fault: "client",
|
|
3104
2757
|
$metadata: deserializeMetadata(output),
|
|
3105
|
-
};
|
|
2758
|
+
});
|
|
2759
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3106
2760
|
}
|
|
3107
|
-
const message = response.message || response.Message || errorCode;
|
|
3108
|
-
response.message = message;
|
|
3109
|
-
delete response.Message;
|
|
3110
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3111
2761
|
};
|
|
3112
2762
|
const deserializeAws_restJson1EnableOrganizationAdminAccountCommand = async (output, context) => {
|
|
3113
2763
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3131,35 +2781,19 @@ const deserializeAws_restJson1EnableOrganizationAdminAccountCommandError = async
|
|
|
3131
2781
|
switch (errorCode) {
|
|
3132
2782
|
case "BadRequestException":
|
|
3133
2783
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3134
|
-
|
|
3135
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3136
|
-
name: errorCode,
|
|
3137
|
-
$metadata: deserializeMetadata(output),
|
|
3138
|
-
};
|
|
3139
|
-
break;
|
|
2784
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3140
2785
|
case "InternalServerErrorException":
|
|
3141
2786
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3142
|
-
|
|
3143
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3144
|
-
name: errorCode,
|
|
3145
|
-
$metadata: deserializeMetadata(output),
|
|
3146
|
-
};
|
|
3147
|
-
break;
|
|
2787
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3148
2788
|
default:
|
|
3149
2789
|
const parsedBody = parsedOutput.body;
|
|
3150
|
-
|
|
3151
|
-
|
|
3152
|
-
...parsedBody,
|
|
3153
|
-
name: `${errorCode}`,
|
|
3154
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2790
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2791
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3155
2792
|
$fault: "client",
|
|
3156
2793
|
$metadata: deserializeMetadata(output),
|
|
3157
|
-
};
|
|
2794
|
+
});
|
|
2795
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3158
2796
|
}
|
|
3159
|
-
const message = response.message || response.Message || errorCode;
|
|
3160
|
-
response.message = message;
|
|
3161
|
-
delete response.Message;
|
|
3162
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3163
2797
|
};
|
|
3164
2798
|
const deserializeAws_restJson1GetDetectorCommand = async (output, context) => {
|
|
3165
2799
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3211,35 +2845,19 @@ const deserializeAws_restJson1GetDetectorCommandError = async (output, context)
|
|
|
3211
2845
|
switch (errorCode) {
|
|
3212
2846
|
case "BadRequestException":
|
|
3213
2847
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3214
|
-
|
|
3215
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3216
|
-
name: errorCode,
|
|
3217
|
-
$metadata: deserializeMetadata(output),
|
|
3218
|
-
};
|
|
3219
|
-
break;
|
|
2848
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3220
2849
|
case "InternalServerErrorException":
|
|
3221
2850
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3222
|
-
|
|
3223
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3224
|
-
name: errorCode,
|
|
3225
|
-
$metadata: deserializeMetadata(output),
|
|
3226
|
-
};
|
|
3227
|
-
break;
|
|
2851
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3228
2852
|
default:
|
|
3229
2853
|
const parsedBody = parsedOutput.body;
|
|
3230
|
-
|
|
3231
|
-
|
|
3232
|
-
...parsedBody,
|
|
3233
|
-
name: `${errorCode}`,
|
|
3234
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2854
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2855
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3235
2856
|
$fault: "client",
|
|
3236
2857
|
$metadata: deserializeMetadata(output),
|
|
3237
|
-
};
|
|
2858
|
+
});
|
|
2859
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3238
2860
|
}
|
|
3239
|
-
const message = response.message || response.Message || errorCode;
|
|
3240
|
-
response.message = message;
|
|
3241
|
-
delete response.Message;
|
|
3242
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3243
2861
|
};
|
|
3244
2862
|
const deserializeAws_restJson1GetFilterCommand = async (output, context) => {
|
|
3245
2863
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3287,35 +2905,19 @@ const deserializeAws_restJson1GetFilterCommandError = async (output, context) =>
|
|
|
3287
2905
|
switch (errorCode) {
|
|
3288
2906
|
case "BadRequestException":
|
|
3289
2907
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3290
|
-
|
|
3291
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3292
|
-
name: errorCode,
|
|
3293
|
-
$metadata: deserializeMetadata(output),
|
|
3294
|
-
};
|
|
3295
|
-
break;
|
|
2908
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3296
2909
|
case "InternalServerErrorException":
|
|
3297
2910
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3298
|
-
|
|
3299
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3300
|
-
name: errorCode,
|
|
3301
|
-
$metadata: deserializeMetadata(output),
|
|
3302
|
-
};
|
|
3303
|
-
break;
|
|
2911
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3304
2912
|
default:
|
|
3305
2913
|
const parsedBody = parsedOutput.body;
|
|
3306
|
-
|
|
3307
|
-
|
|
3308
|
-
...parsedBody,
|
|
3309
|
-
name: `${errorCode}`,
|
|
3310
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2914
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2915
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3311
2916
|
$fault: "client",
|
|
3312
2917
|
$metadata: deserializeMetadata(output),
|
|
3313
|
-
};
|
|
2918
|
+
});
|
|
2919
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3314
2920
|
}
|
|
3315
|
-
const message = response.message || response.Message || errorCode;
|
|
3316
|
-
response.message = message;
|
|
3317
|
-
delete response.Message;
|
|
3318
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3319
2921
|
};
|
|
3320
2922
|
const deserializeAws_restJson1GetFindingsCommand = async (output, context) => {
|
|
3321
2923
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3343,35 +2945,19 @@ const deserializeAws_restJson1GetFindingsCommandError = async (output, context)
|
|
|
3343
2945
|
switch (errorCode) {
|
|
3344
2946
|
case "BadRequestException":
|
|
3345
2947
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3346
|
-
|
|
3347
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3348
|
-
name: errorCode,
|
|
3349
|
-
$metadata: deserializeMetadata(output),
|
|
3350
|
-
};
|
|
3351
|
-
break;
|
|
2948
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3352
2949
|
case "InternalServerErrorException":
|
|
3353
2950
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3354
|
-
|
|
3355
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3356
|
-
name: errorCode,
|
|
3357
|
-
$metadata: deserializeMetadata(output),
|
|
3358
|
-
};
|
|
3359
|
-
break;
|
|
2951
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3360
2952
|
default:
|
|
3361
2953
|
const parsedBody = parsedOutput.body;
|
|
3362
|
-
|
|
3363
|
-
|
|
3364
|
-
...parsedBody,
|
|
3365
|
-
name: `${errorCode}`,
|
|
3366
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2954
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2955
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3367
2956
|
$fault: "client",
|
|
3368
2957
|
$metadata: deserializeMetadata(output),
|
|
3369
|
-
};
|
|
2958
|
+
});
|
|
2959
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3370
2960
|
}
|
|
3371
|
-
const message = response.message || response.Message || errorCode;
|
|
3372
|
-
response.message = message;
|
|
3373
|
-
delete response.Message;
|
|
3374
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3375
2961
|
};
|
|
3376
2962
|
const deserializeAws_restJson1GetFindingsStatisticsCommand = async (output, context) => {
|
|
3377
2963
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3399,35 +2985,19 @@ const deserializeAws_restJson1GetFindingsStatisticsCommandError = async (output,
|
|
|
3399
2985
|
switch (errorCode) {
|
|
3400
2986
|
case "BadRequestException":
|
|
3401
2987
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3402
|
-
|
|
3403
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3404
|
-
name: errorCode,
|
|
3405
|
-
$metadata: deserializeMetadata(output),
|
|
3406
|
-
};
|
|
3407
|
-
break;
|
|
2988
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3408
2989
|
case "InternalServerErrorException":
|
|
3409
2990
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3410
|
-
|
|
3411
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3412
|
-
name: errorCode,
|
|
3413
|
-
$metadata: deserializeMetadata(output),
|
|
3414
|
-
};
|
|
3415
|
-
break;
|
|
2991
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3416
2992
|
default:
|
|
3417
2993
|
const parsedBody = parsedOutput.body;
|
|
3418
|
-
|
|
3419
|
-
|
|
3420
|
-
...parsedBody,
|
|
3421
|
-
name: `${errorCode}`,
|
|
3422
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2994
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
2995
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3423
2996
|
$fault: "client",
|
|
3424
2997
|
$metadata: deserializeMetadata(output),
|
|
3425
|
-
};
|
|
2998
|
+
});
|
|
2999
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3426
3000
|
}
|
|
3427
|
-
const message = response.message || response.Message || errorCode;
|
|
3428
|
-
response.message = message;
|
|
3429
|
-
delete response.Message;
|
|
3430
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3431
3001
|
};
|
|
3432
3002
|
const deserializeAws_restJson1GetInvitationsCountCommand = async (output, context) => {
|
|
3433
3003
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3455,35 +3025,19 @@ const deserializeAws_restJson1GetInvitationsCountCommandError = async (output, c
|
|
|
3455
3025
|
switch (errorCode) {
|
|
3456
3026
|
case "BadRequestException":
|
|
3457
3027
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3458
|
-
|
|
3459
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3460
|
-
name: errorCode,
|
|
3461
|
-
$metadata: deserializeMetadata(output),
|
|
3462
|
-
};
|
|
3463
|
-
break;
|
|
3028
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3464
3029
|
case "InternalServerErrorException":
|
|
3465
3030
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3466
|
-
|
|
3467
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3468
|
-
name: errorCode,
|
|
3469
|
-
$metadata: deserializeMetadata(output),
|
|
3470
|
-
};
|
|
3471
|
-
break;
|
|
3031
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3472
3032
|
default:
|
|
3473
3033
|
const parsedBody = parsedOutput.body;
|
|
3474
|
-
|
|
3475
|
-
|
|
3476
|
-
...parsedBody,
|
|
3477
|
-
name: `${errorCode}`,
|
|
3478
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3034
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3035
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3479
3036
|
$fault: "client",
|
|
3480
3037
|
$metadata: deserializeMetadata(output),
|
|
3481
|
-
};
|
|
3038
|
+
});
|
|
3039
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3482
3040
|
}
|
|
3483
|
-
const message = response.message || response.Message || errorCode;
|
|
3484
|
-
response.message = message;
|
|
3485
|
-
delete response.Message;
|
|
3486
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3487
3041
|
};
|
|
3488
3042
|
const deserializeAws_restJson1GetIPSetCommand = async (output, context) => {
|
|
3489
3043
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3527,35 +3081,19 @@ const deserializeAws_restJson1GetIPSetCommandError = async (output, context) =>
|
|
|
3527
3081
|
switch (errorCode) {
|
|
3528
3082
|
case "BadRequestException":
|
|
3529
3083
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3530
|
-
|
|
3531
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3532
|
-
name: errorCode,
|
|
3533
|
-
$metadata: deserializeMetadata(output),
|
|
3534
|
-
};
|
|
3535
|
-
break;
|
|
3084
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3536
3085
|
case "InternalServerErrorException":
|
|
3537
3086
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3538
|
-
|
|
3539
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3540
|
-
name: errorCode,
|
|
3541
|
-
$metadata: deserializeMetadata(output),
|
|
3542
|
-
};
|
|
3543
|
-
break;
|
|
3087
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3544
3088
|
default:
|
|
3545
3089
|
const parsedBody = parsedOutput.body;
|
|
3546
|
-
|
|
3547
|
-
|
|
3548
|
-
...parsedBody,
|
|
3549
|
-
name: `${errorCode}`,
|
|
3550
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3090
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3091
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3551
3092
|
$fault: "client",
|
|
3552
3093
|
$metadata: deserializeMetadata(output),
|
|
3553
|
-
};
|
|
3094
|
+
});
|
|
3095
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3554
3096
|
}
|
|
3555
|
-
const message = response.message || response.Message || errorCode;
|
|
3556
|
-
response.message = message;
|
|
3557
|
-
delete response.Message;
|
|
3558
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3559
3097
|
};
|
|
3560
3098
|
const deserializeAws_restJson1GetMasterAccountCommand = async (output, context) => {
|
|
3561
3099
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3583,35 +3121,19 @@ const deserializeAws_restJson1GetMasterAccountCommandError = async (output, cont
|
|
|
3583
3121
|
switch (errorCode) {
|
|
3584
3122
|
case "BadRequestException":
|
|
3585
3123
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3586
|
-
|
|
3587
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3588
|
-
name: errorCode,
|
|
3589
|
-
$metadata: deserializeMetadata(output),
|
|
3590
|
-
};
|
|
3591
|
-
break;
|
|
3124
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3592
3125
|
case "InternalServerErrorException":
|
|
3593
3126
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3594
|
-
|
|
3595
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3596
|
-
name: errorCode,
|
|
3597
|
-
$metadata: deserializeMetadata(output),
|
|
3598
|
-
};
|
|
3599
|
-
break;
|
|
3127
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3600
3128
|
default:
|
|
3601
3129
|
const parsedBody = parsedOutput.body;
|
|
3602
|
-
|
|
3603
|
-
|
|
3604
|
-
...parsedBody,
|
|
3605
|
-
name: `${errorCode}`,
|
|
3606
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3130
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3131
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3607
3132
|
$fault: "client",
|
|
3608
3133
|
$metadata: deserializeMetadata(output),
|
|
3609
|
-
};
|
|
3134
|
+
});
|
|
3135
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3610
3136
|
}
|
|
3611
|
-
const message = response.message || response.Message || errorCode;
|
|
3612
|
-
response.message = message;
|
|
3613
|
-
delete response.Message;
|
|
3614
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3615
3137
|
};
|
|
3616
3138
|
const deserializeAws_restJson1GetMemberDetectorsCommand = async (output, context) => {
|
|
3617
3139
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3643,35 +3165,19 @@ const deserializeAws_restJson1GetMemberDetectorsCommandError = async (output, co
|
|
|
3643
3165
|
switch (errorCode) {
|
|
3644
3166
|
case "BadRequestException":
|
|
3645
3167
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3646
|
-
|
|
3647
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3648
|
-
name: errorCode,
|
|
3649
|
-
$metadata: deserializeMetadata(output),
|
|
3650
|
-
};
|
|
3651
|
-
break;
|
|
3168
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3652
3169
|
case "InternalServerErrorException":
|
|
3653
3170
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3654
|
-
|
|
3655
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3656
|
-
name: errorCode,
|
|
3657
|
-
$metadata: deserializeMetadata(output),
|
|
3658
|
-
};
|
|
3659
|
-
break;
|
|
3171
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3660
3172
|
default:
|
|
3661
3173
|
const parsedBody = parsedOutput.body;
|
|
3662
|
-
|
|
3663
|
-
|
|
3664
|
-
...parsedBody,
|
|
3665
|
-
name: `${errorCode}`,
|
|
3666
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3174
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3175
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3667
3176
|
$fault: "client",
|
|
3668
3177
|
$metadata: deserializeMetadata(output),
|
|
3669
|
-
};
|
|
3178
|
+
});
|
|
3179
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3670
3180
|
}
|
|
3671
|
-
const message = response.message || response.Message || errorCode;
|
|
3672
|
-
response.message = message;
|
|
3673
|
-
delete response.Message;
|
|
3674
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3675
3181
|
};
|
|
3676
3182
|
const deserializeAws_restJson1GetMembersCommand = async (output, context) => {
|
|
3677
3183
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3703,35 +3209,19 @@ const deserializeAws_restJson1GetMembersCommandError = async (output, context) =
|
|
|
3703
3209
|
switch (errorCode) {
|
|
3704
3210
|
case "BadRequestException":
|
|
3705
3211
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3706
|
-
|
|
3707
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3708
|
-
name: errorCode,
|
|
3709
|
-
$metadata: deserializeMetadata(output),
|
|
3710
|
-
};
|
|
3711
|
-
break;
|
|
3212
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3712
3213
|
case "InternalServerErrorException":
|
|
3713
3214
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3714
|
-
|
|
3715
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3716
|
-
name: errorCode,
|
|
3717
|
-
$metadata: deserializeMetadata(output),
|
|
3718
|
-
};
|
|
3719
|
-
break;
|
|
3215
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3720
3216
|
default:
|
|
3721
3217
|
const parsedBody = parsedOutput.body;
|
|
3722
|
-
|
|
3723
|
-
|
|
3724
|
-
...parsedBody,
|
|
3725
|
-
name: `${errorCode}`,
|
|
3726
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3218
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3219
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3727
3220
|
$fault: "client",
|
|
3728
3221
|
$metadata: deserializeMetadata(output),
|
|
3729
|
-
};
|
|
3222
|
+
});
|
|
3223
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3730
3224
|
}
|
|
3731
|
-
const message = response.message || response.Message || errorCode;
|
|
3732
|
-
response.message = message;
|
|
3733
|
-
delete response.Message;
|
|
3734
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3735
3225
|
};
|
|
3736
3226
|
const deserializeAws_restJson1GetThreatIntelSetCommand = async (output, context) => {
|
|
3737
3227
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3775,35 +3265,19 @@ const deserializeAws_restJson1GetThreatIntelSetCommandError = async (output, con
|
|
|
3775
3265
|
switch (errorCode) {
|
|
3776
3266
|
case "BadRequestException":
|
|
3777
3267
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3778
|
-
|
|
3779
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3780
|
-
name: errorCode,
|
|
3781
|
-
$metadata: deserializeMetadata(output),
|
|
3782
|
-
};
|
|
3783
|
-
break;
|
|
3268
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3784
3269
|
case "InternalServerErrorException":
|
|
3785
3270
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3786
|
-
|
|
3787
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3788
|
-
name: errorCode,
|
|
3789
|
-
$metadata: deserializeMetadata(output),
|
|
3790
|
-
};
|
|
3791
|
-
break;
|
|
3271
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3792
3272
|
default:
|
|
3793
3273
|
const parsedBody = parsedOutput.body;
|
|
3794
|
-
|
|
3795
|
-
|
|
3796
|
-
...parsedBody,
|
|
3797
|
-
name: `${errorCode}`,
|
|
3798
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3274
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3275
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3799
3276
|
$fault: "client",
|
|
3800
3277
|
$metadata: deserializeMetadata(output),
|
|
3801
|
-
};
|
|
3278
|
+
});
|
|
3279
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3802
3280
|
}
|
|
3803
|
-
const message = response.message || response.Message || errorCode;
|
|
3804
|
-
response.message = message;
|
|
3805
|
-
delete response.Message;
|
|
3806
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3807
3281
|
};
|
|
3808
3282
|
const deserializeAws_restJson1GetUsageStatisticsCommand = async (output, context) => {
|
|
3809
3283
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3835,35 +3309,19 @@ const deserializeAws_restJson1GetUsageStatisticsCommandError = async (output, co
|
|
|
3835
3309
|
switch (errorCode) {
|
|
3836
3310
|
case "BadRequestException":
|
|
3837
3311
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3838
|
-
|
|
3839
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3840
|
-
name: errorCode,
|
|
3841
|
-
$metadata: deserializeMetadata(output),
|
|
3842
|
-
};
|
|
3843
|
-
break;
|
|
3312
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3844
3313
|
case "InternalServerErrorException":
|
|
3845
3314
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3846
|
-
|
|
3847
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3848
|
-
name: errorCode,
|
|
3849
|
-
$metadata: deserializeMetadata(output),
|
|
3850
|
-
};
|
|
3851
|
-
break;
|
|
3315
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3852
3316
|
default:
|
|
3853
3317
|
const parsedBody = parsedOutput.body;
|
|
3854
|
-
|
|
3855
|
-
|
|
3856
|
-
...parsedBody,
|
|
3857
|
-
name: `${errorCode}`,
|
|
3858
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3318
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3319
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3859
3320
|
$fault: "client",
|
|
3860
3321
|
$metadata: deserializeMetadata(output),
|
|
3861
|
-
};
|
|
3322
|
+
});
|
|
3323
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3862
3324
|
}
|
|
3863
|
-
const message = response.message || response.Message || errorCode;
|
|
3864
|
-
response.message = message;
|
|
3865
|
-
delete response.Message;
|
|
3866
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3867
3325
|
};
|
|
3868
3326
|
const deserializeAws_restJson1InviteMembersCommand = async (output, context) => {
|
|
3869
3327
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3891,35 +3349,19 @@ const deserializeAws_restJson1InviteMembersCommandError = async (output, context
|
|
|
3891
3349
|
switch (errorCode) {
|
|
3892
3350
|
case "BadRequestException":
|
|
3893
3351
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3894
|
-
|
|
3895
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3896
|
-
name: errorCode,
|
|
3897
|
-
$metadata: deserializeMetadata(output),
|
|
3898
|
-
};
|
|
3899
|
-
break;
|
|
3352
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3900
3353
|
case "InternalServerErrorException":
|
|
3901
3354
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3902
|
-
|
|
3903
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3904
|
-
name: errorCode,
|
|
3905
|
-
$metadata: deserializeMetadata(output),
|
|
3906
|
-
};
|
|
3907
|
-
break;
|
|
3355
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3908
3356
|
default:
|
|
3909
3357
|
const parsedBody = parsedOutput.body;
|
|
3910
|
-
|
|
3911
|
-
|
|
3912
|
-
...parsedBody,
|
|
3913
|
-
name: `${errorCode}`,
|
|
3914
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3358
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3359
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3915
3360
|
$fault: "client",
|
|
3916
3361
|
$metadata: deserializeMetadata(output),
|
|
3917
|
-
};
|
|
3362
|
+
});
|
|
3363
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3918
3364
|
}
|
|
3919
|
-
const message = response.message || response.Message || errorCode;
|
|
3920
|
-
response.message = message;
|
|
3921
|
-
delete response.Message;
|
|
3922
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3923
3365
|
};
|
|
3924
3366
|
const deserializeAws_restJson1ListDetectorsCommand = async (output, context) => {
|
|
3925
3367
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3951,35 +3393,19 @@ const deserializeAws_restJson1ListDetectorsCommandError = async (output, context
|
|
|
3951
3393
|
switch (errorCode) {
|
|
3952
3394
|
case "BadRequestException":
|
|
3953
3395
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
3954
|
-
|
|
3955
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3956
|
-
name: errorCode,
|
|
3957
|
-
$metadata: deserializeMetadata(output),
|
|
3958
|
-
};
|
|
3959
|
-
break;
|
|
3396
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3960
3397
|
case "InternalServerErrorException":
|
|
3961
3398
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
3962
|
-
|
|
3963
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3964
|
-
name: errorCode,
|
|
3965
|
-
$metadata: deserializeMetadata(output),
|
|
3966
|
-
};
|
|
3967
|
-
break;
|
|
3399
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3968
3400
|
default:
|
|
3969
3401
|
const parsedBody = parsedOutput.body;
|
|
3970
|
-
|
|
3971
|
-
|
|
3972
|
-
...parsedBody,
|
|
3973
|
-
name: `${errorCode}`,
|
|
3974
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3402
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3403
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3975
3404
|
$fault: "client",
|
|
3976
3405
|
$metadata: deserializeMetadata(output),
|
|
3977
|
-
};
|
|
3406
|
+
});
|
|
3407
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3978
3408
|
}
|
|
3979
|
-
const message = response.message || response.Message || errorCode;
|
|
3980
|
-
response.message = message;
|
|
3981
|
-
delete response.Message;
|
|
3982
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3983
3409
|
};
|
|
3984
3410
|
const deserializeAws_restJson1ListFiltersCommand = async (output, context) => {
|
|
3985
3411
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4011,35 +3437,19 @@ const deserializeAws_restJson1ListFiltersCommandError = async (output, context)
|
|
|
4011
3437
|
switch (errorCode) {
|
|
4012
3438
|
case "BadRequestException":
|
|
4013
3439
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4014
|
-
|
|
4015
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4016
|
-
name: errorCode,
|
|
4017
|
-
$metadata: deserializeMetadata(output),
|
|
4018
|
-
};
|
|
4019
|
-
break;
|
|
3440
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4020
3441
|
case "InternalServerErrorException":
|
|
4021
3442
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4022
|
-
|
|
4023
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4024
|
-
name: errorCode,
|
|
4025
|
-
$metadata: deserializeMetadata(output),
|
|
4026
|
-
};
|
|
4027
|
-
break;
|
|
3443
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4028
3444
|
default:
|
|
4029
3445
|
const parsedBody = parsedOutput.body;
|
|
4030
|
-
|
|
4031
|
-
|
|
4032
|
-
...parsedBody,
|
|
4033
|
-
name: `${errorCode}`,
|
|
4034
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3446
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3447
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4035
3448
|
$fault: "client",
|
|
4036
3449
|
$metadata: deserializeMetadata(output),
|
|
4037
|
-
};
|
|
3450
|
+
});
|
|
3451
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4038
3452
|
}
|
|
4039
|
-
const message = response.message || response.Message || errorCode;
|
|
4040
|
-
response.message = message;
|
|
4041
|
-
delete response.Message;
|
|
4042
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4043
3453
|
};
|
|
4044
3454
|
const deserializeAws_restJson1ListFindingsCommand = async (output, context) => {
|
|
4045
3455
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4071,35 +3481,19 @@ const deserializeAws_restJson1ListFindingsCommandError = async (output, context)
|
|
|
4071
3481
|
switch (errorCode) {
|
|
4072
3482
|
case "BadRequestException":
|
|
4073
3483
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4074
|
-
|
|
4075
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4076
|
-
name: errorCode,
|
|
4077
|
-
$metadata: deserializeMetadata(output),
|
|
4078
|
-
};
|
|
4079
|
-
break;
|
|
3484
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4080
3485
|
case "InternalServerErrorException":
|
|
4081
3486
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4082
|
-
|
|
4083
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4084
|
-
name: errorCode,
|
|
4085
|
-
$metadata: deserializeMetadata(output),
|
|
4086
|
-
};
|
|
4087
|
-
break;
|
|
3487
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4088
3488
|
default:
|
|
4089
3489
|
const parsedBody = parsedOutput.body;
|
|
4090
|
-
|
|
4091
|
-
|
|
4092
|
-
...parsedBody,
|
|
4093
|
-
name: `${errorCode}`,
|
|
4094
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3490
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3491
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4095
3492
|
$fault: "client",
|
|
4096
3493
|
$metadata: deserializeMetadata(output),
|
|
4097
|
-
};
|
|
3494
|
+
});
|
|
3495
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4098
3496
|
}
|
|
4099
|
-
const message = response.message || response.Message || errorCode;
|
|
4100
|
-
response.message = message;
|
|
4101
|
-
delete response.Message;
|
|
4102
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4103
3497
|
};
|
|
4104
3498
|
const deserializeAws_restJson1ListInvitationsCommand = async (output, context) => {
|
|
4105
3499
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4131,35 +3525,19 @@ const deserializeAws_restJson1ListInvitationsCommandError = async (output, conte
|
|
|
4131
3525
|
switch (errorCode) {
|
|
4132
3526
|
case "BadRequestException":
|
|
4133
3527
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4134
|
-
|
|
4135
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4136
|
-
name: errorCode,
|
|
4137
|
-
$metadata: deserializeMetadata(output),
|
|
4138
|
-
};
|
|
4139
|
-
break;
|
|
3528
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4140
3529
|
case "InternalServerErrorException":
|
|
4141
3530
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4142
|
-
|
|
4143
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4144
|
-
name: errorCode,
|
|
4145
|
-
$metadata: deserializeMetadata(output),
|
|
4146
|
-
};
|
|
4147
|
-
break;
|
|
3531
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4148
3532
|
default:
|
|
4149
3533
|
const parsedBody = parsedOutput.body;
|
|
4150
|
-
|
|
4151
|
-
|
|
4152
|
-
...parsedBody,
|
|
4153
|
-
name: `${errorCode}`,
|
|
4154
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3534
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3535
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4155
3536
|
$fault: "client",
|
|
4156
3537
|
$metadata: deserializeMetadata(output),
|
|
4157
|
-
};
|
|
3538
|
+
});
|
|
3539
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4158
3540
|
}
|
|
4159
|
-
const message = response.message || response.Message || errorCode;
|
|
4160
|
-
response.message = message;
|
|
4161
|
-
delete response.Message;
|
|
4162
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4163
3541
|
};
|
|
4164
3542
|
const deserializeAws_restJson1ListIPSetsCommand = async (output, context) => {
|
|
4165
3543
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4191,35 +3569,19 @@ const deserializeAws_restJson1ListIPSetsCommandError = async (output, context) =
|
|
|
4191
3569
|
switch (errorCode) {
|
|
4192
3570
|
case "BadRequestException":
|
|
4193
3571
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4194
|
-
|
|
4195
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4196
|
-
name: errorCode,
|
|
4197
|
-
$metadata: deserializeMetadata(output),
|
|
4198
|
-
};
|
|
4199
|
-
break;
|
|
3572
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4200
3573
|
case "InternalServerErrorException":
|
|
4201
3574
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4202
|
-
|
|
4203
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4204
|
-
name: errorCode,
|
|
4205
|
-
$metadata: deserializeMetadata(output),
|
|
4206
|
-
};
|
|
4207
|
-
break;
|
|
3575
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4208
3576
|
default:
|
|
4209
3577
|
const parsedBody = parsedOutput.body;
|
|
4210
|
-
|
|
4211
|
-
|
|
4212
|
-
...parsedBody,
|
|
4213
|
-
name: `${errorCode}`,
|
|
4214
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3578
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3579
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4215
3580
|
$fault: "client",
|
|
4216
3581
|
$metadata: deserializeMetadata(output),
|
|
4217
|
-
};
|
|
3582
|
+
});
|
|
3583
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4218
3584
|
}
|
|
4219
|
-
const message = response.message || response.Message || errorCode;
|
|
4220
|
-
response.message = message;
|
|
4221
|
-
delete response.Message;
|
|
4222
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4223
3585
|
};
|
|
4224
3586
|
const deserializeAws_restJson1ListMembersCommand = async (output, context) => {
|
|
4225
3587
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4251,35 +3613,19 @@ const deserializeAws_restJson1ListMembersCommandError = async (output, context)
|
|
|
4251
3613
|
switch (errorCode) {
|
|
4252
3614
|
case "BadRequestException":
|
|
4253
3615
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4254
|
-
|
|
4255
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4256
|
-
name: errorCode,
|
|
4257
|
-
$metadata: deserializeMetadata(output),
|
|
4258
|
-
};
|
|
4259
|
-
break;
|
|
3616
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4260
3617
|
case "InternalServerErrorException":
|
|
4261
3618
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4262
|
-
|
|
4263
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4264
|
-
name: errorCode,
|
|
4265
|
-
$metadata: deserializeMetadata(output),
|
|
4266
|
-
};
|
|
4267
|
-
break;
|
|
3619
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4268
3620
|
default:
|
|
4269
3621
|
const parsedBody = parsedOutput.body;
|
|
4270
|
-
|
|
4271
|
-
|
|
4272
|
-
...parsedBody,
|
|
4273
|
-
name: `${errorCode}`,
|
|
4274
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3622
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3623
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4275
3624
|
$fault: "client",
|
|
4276
3625
|
$metadata: deserializeMetadata(output),
|
|
4277
|
-
};
|
|
3626
|
+
});
|
|
3627
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4278
3628
|
}
|
|
4279
|
-
const message = response.message || response.Message || errorCode;
|
|
4280
|
-
response.message = message;
|
|
4281
|
-
delete response.Message;
|
|
4282
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4283
3629
|
};
|
|
4284
3630
|
const deserializeAws_restJson1ListOrganizationAdminAccountsCommand = async (output, context) => {
|
|
4285
3631
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4311,35 +3657,19 @@ const deserializeAws_restJson1ListOrganizationAdminAccountsCommandError = async
|
|
|
4311
3657
|
switch (errorCode) {
|
|
4312
3658
|
case "BadRequestException":
|
|
4313
3659
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4314
|
-
|
|
4315
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4316
|
-
name: errorCode,
|
|
4317
|
-
$metadata: deserializeMetadata(output),
|
|
4318
|
-
};
|
|
4319
|
-
break;
|
|
3660
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4320
3661
|
case "InternalServerErrorException":
|
|
4321
3662
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4322
|
-
|
|
4323
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4324
|
-
name: errorCode,
|
|
4325
|
-
$metadata: deserializeMetadata(output),
|
|
4326
|
-
};
|
|
4327
|
-
break;
|
|
3663
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4328
3664
|
default:
|
|
4329
3665
|
const parsedBody = parsedOutput.body;
|
|
4330
|
-
|
|
4331
|
-
|
|
4332
|
-
...parsedBody,
|
|
4333
|
-
name: `${errorCode}`,
|
|
4334
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3666
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3667
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4335
3668
|
$fault: "client",
|
|
4336
3669
|
$metadata: deserializeMetadata(output),
|
|
4337
|
-
};
|
|
3670
|
+
});
|
|
3671
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4338
3672
|
}
|
|
4339
|
-
const message = response.message || response.Message || errorCode;
|
|
4340
|
-
response.message = message;
|
|
4341
|
-
delete response.Message;
|
|
4342
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4343
3673
|
};
|
|
4344
3674
|
const deserializeAws_restJson1ListPublishingDestinationsCommand = async (output, context) => {
|
|
4345
3675
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4371,35 +3701,19 @@ const deserializeAws_restJson1ListPublishingDestinationsCommandError = async (ou
|
|
|
4371
3701
|
switch (errorCode) {
|
|
4372
3702
|
case "BadRequestException":
|
|
4373
3703
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4374
|
-
|
|
4375
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4376
|
-
name: errorCode,
|
|
4377
|
-
$metadata: deserializeMetadata(output),
|
|
4378
|
-
};
|
|
4379
|
-
break;
|
|
3704
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4380
3705
|
case "InternalServerErrorException":
|
|
4381
3706
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4382
|
-
|
|
4383
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4384
|
-
name: errorCode,
|
|
4385
|
-
$metadata: deserializeMetadata(output),
|
|
4386
|
-
};
|
|
4387
|
-
break;
|
|
3707
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4388
3708
|
default:
|
|
4389
3709
|
const parsedBody = parsedOutput.body;
|
|
4390
|
-
|
|
4391
|
-
|
|
4392
|
-
...parsedBody,
|
|
4393
|
-
name: `${errorCode}`,
|
|
4394
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3710
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3711
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4395
3712
|
$fault: "client",
|
|
4396
3713
|
$metadata: deserializeMetadata(output),
|
|
4397
|
-
};
|
|
3714
|
+
});
|
|
3715
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4398
3716
|
}
|
|
4399
|
-
const message = response.message || response.Message || errorCode;
|
|
4400
|
-
response.message = message;
|
|
4401
|
-
delete response.Message;
|
|
4402
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4403
3717
|
};
|
|
4404
3718
|
const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
|
|
4405
3719
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4427,35 +3741,19 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
|
|
|
4427
3741
|
switch (errorCode) {
|
|
4428
3742
|
case "BadRequestException":
|
|
4429
3743
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4430
|
-
|
|
4431
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4432
|
-
name: errorCode,
|
|
4433
|
-
$metadata: deserializeMetadata(output),
|
|
4434
|
-
};
|
|
4435
|
-
break;
|
|
3744
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4436
3745
|
case "InternalServerErrorException":
|
|
4437
3746
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4438
|
-
|
|
4439
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4440
|
-
name: errorCode,
|
|
4441
|
-
$metadata: deserializeMetadata(output),
|
|
4442
|
-
};
|
|
4443
|
-
break;
|
|
3747
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4444
3748
|
default:
|
|
4445
3749
|
const parsedBody = parsedOutput.body;
|
|
4446
|
-
|
|
4447
|
-
|
|
4448
|
-
...parsedBody,
|
|
4449
|
-
name: `${errorCode}`,
|
|
4450
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3750
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3751
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4451
3752
|
$fault: "client",
|
|
4452
3753
|
$metadata: deserializeMetadata(output),
|
|
4453
|
-
};
|
|
3754
|
+
});
|
|
3755
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4454
3756
|
}
|
|
4455
|
-
const message = response.message || response.Message || errorCode;
|
|
4456
|
-
response.message = message;
|
|
4457
|
-
delete response.Message;
|
|
4458
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4459
3757
|
};
|
|
4460
3758
|
const deserializeAws_restJson1ListThreatIntelSetsCommand = async (output, context) => {
|
|
4461
3759
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4487,35 +3785,19 @@ const deserializeAws_restJson1ListThreatIntelSetsCommandError = async (output, c
|
|
|
4487
3785
|
switch (errorCode) {
|
|
4488
3786
|
case "BadRequestException":
|
|
4489
3787
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4490
|
-
|
|
4491
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4492
|
-
name: errorCode,
|
|
4493
|
-
$metadata: deserializeMetadata(output),
|
|
4494
|
-
};
|
|
4495
|
-
break;
|
|
3788
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4496
3789
|
case "InternalServerErrorException":
|
|
4497
3790
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4498
|
-
|
|
4499
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4500
|
-
name: errorCode,
|
|
4501
|
-
$metadata: deserializeMetadata(output),
|
|
4502
|
-
};
|
|
4503
|
-
break;
|
|
3791
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4504
3792
|
default:
|
|
4505
3793
|
const parsedBody = parsedOutput.body;
|
|
4506
|
-
|
|
4507
|
-
|
|
4508
|
-
...parsedBody,
|
|
4509
|
-
name: `${errorCode}`,
|
|
4510
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3794
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3795
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4511
3796
|
$fault: "client",
|
|
4512
3797
|
$metadata: deserializeMetadata(output),
|
|
4513
|
-
};
|
|
3798
|
+
});
|
|
3799
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4514
3800
|
}
|
|
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
3801
|
};
|
|
4520
3802
|
const deserializeAws_restJson1StartMonitoringMembersCommand = async (output, context) => {
|
|
4521
3803
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4543,35 +3825,19 @@ const deserializeAws_restJson1StartMonitoringMembersCommandError = async (output
|
|
|
4543
3825
|
switch (errorCode) {
|
|
4544
3826
|
case "BadRequestException":
|
|
4545
3827
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4546
|
-
|
|
4547
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4548
|
-
name: errorCode,
|
|
4549
|
-
$metadata: deserializeMetadata(output),
|
|
4550
|
-
};
|
|
4551
|
-
break;
|
|
3828
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4552
3829
|
case "InternalServerErrorException":
|
|
4553
3830
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4554
|
-
|
|
4555
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4556
|
-
name: errorCode,
|
|
4557
|
-
$metadata: deserializeMetadata(output),
|
|
4558
|
-
};
|
|
4559
|
-
break;
|
|
3831
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4560
3832
|
default:
|
|
4561
3833
|
const parsedBody = parsedOutput.body;
|
|
4562
|
-
|
|
4563
|
-
|
|
4564
|
-
...parsedBody,
|
|
4565
|
-
name: `${errorCode}`,
|
|
4566
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3834
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3835
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4567
3836
|
$fault: "client",
|
|
4568
3837
|
$metadata: deserializeMetadata(output),
|
|
4569
|
-
};
|
|
3838
|
+
});
|
|
3839
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4570
3840
|
}
|
|
4571
|
-
const message = response.message || response.Message || errorCode;
|
|
4572
|
-
response.message = message;
|
|
4573
|
-
delete response.Message;
|
|
4574
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4575
3841
|
};
|
|
4576
3842
|
const deserializeAws_restJson1StopMonitoringMembersCommand = async (output, context) => {
|
|
4577
3843
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4599,35 +3865,19 @@ const deserializeAws_restJson1StopMonitoringMembersCommandError = async (output,
|
|
|
4599
3865
|
switch (errorCode) {
|
|
4600
3866
|
case "BadRequestException":
|
|
4601
3867
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4602
|
-
|
|
4603
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4604
|
-
name: errorCode,
|
|
4605
|
-
$metadata: deserializeMetadata(output),
|
|
4606
|
-
};
|
|
4607
|
-
break;
|
|
3868
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4608
3869
|
case "InternalServerErrorException":
|
|
4609
3870
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4610
|
-
|
|
4611
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4612
|
-
name: errorCode,
|
|
4613
|
-
$metadata: deserializeMetadata(output),
|
|
4614
|
-
};
|
|
4615
|
-
break;
|
|
3871
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4616
3872
|
default:
|
|
4617
3873
|
const parsedBody = parsedOutput.body;
|
|
4618
|
-
|
|
4619
|
-
|
|
4620
|
-
...parsedBody,
|
|
4621
|
-
name: `${errorCode}`,
|
|
4622
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3874
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3875
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4623
3876
|
$fault: "client",
|
|
4624
3877
|
$metadata: deserializeMetadata(output),
|
|
4625
|
-
};
|
|
3878
|
+
});
|
|
3879
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4626
3880
|
}
|
|
4627
|
-
const message = response.message || response.Message || errorCode;
|
|
4628
|
-
response.message = message;
|
|
4629
|
-
delete response.Message;
|
|
4630
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4631
3881
|
};
|
|
4632
3882
|
const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
|
|
4633
3883
|
if (output.statusCode !== 204 && output.statusCode >= 300) {
|
|
@@ -4651,35 +3901,19 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
|
|
|
4651
3901
|
switch (errorCode) {
|
|
4652
3902
|
case "BadRequestException":
|
|
4653
3903
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4654
|
-
|
|
4655
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4656
|
-
name: errorCode,
|
|
4657
|
-
$metadata: deserializeMetadata(output),
|
|
4658
|
-
};
|
|
4659
|
-
break;
|
|
3904
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4660
3905
|
case "InternalServerErrorException":
|
|
4661
3906
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4662
|
-
|
|
4663
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4664
|
-
name: errorCode,
|
|
4665
|
-
$metadata: deserializeMetadata(output),
|
|
4666
|
-
};
|
|
4667
|
-
break;
|
|
3907
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4668
3908
|
default:
|
|
4669
3909
|
const parsedBody = parsedOutput.body;
|
|
4670
|
-
|
|
4671
|
-
|
|
4672
|
-
...parsedBody,
|
|
4673
|
-
name: `${errorCode}`,
|
|
4674
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3910
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3911
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4675
3912
|
$fault: "client",
|
|
4676
3913
|
$metadata: deserializeMetadata(output),
|
|
4677
|
-
};
|
|
3914
|
+
});
|
|
3915
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4678
3916
|
}
|
|
4679
|
-
const message = response.message || response.Message || errorCode;
|
|
4680
|
-
response.message = message;
|
|
4681
|
-
delete response.Message;
|
|
4682
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4683
3917
|
};
|
|
4684
3918
|
const deserializeAws_restJson1UnarchiveFindingsCommand = async (output, context) => {
|
|
4685
3919
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4703,35 +3937,19 @@ const deserializeAws_restJson1UnarchiveFindingsCommandError = async (output, con
|
|
|
4703
3937
|
switch (errorCode) {
|
|
4704
3938
|
case "BadRequestException":
|
|
4705
3939
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4706
|
-
|
|
4707
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4708
|
-
name: errorCode,
|
|
4709
|
-
$metadata: deserializeMetadata(output),
|
|
4710
|
-
};
|
|
4711
|
-
break;
|
|
3940
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4712
3941
|
case "InternalServerErrorException":
|
|
4713
3942
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4714
|
-
|
|
4715
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4716
|
-
name: errorCode,
|
|
4717
|
-
$metadata: deserializeMetadata(output),
|
|
4718
|
-
};
|
|
4719
|
-
break;
|
|
3943
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4720
3944
|
default:
|
|
4721
3945
|
const parsedBody = parsedOutput.body;
|
|
4722
|
-
|
|
4723
|
-
|
|
4724
|
-
...parsedBody,
|
|
4725
|
-
name: `${errorCode}`,
|
|
4726
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3946
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3947
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4727
3948
|
$fault: "client",
|
|
4728
3949
|
$metadata: deserializeMetadata(output),
|
|
4729
|
-
};
|
|
3950
|
+
});
|
|
3951
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4730
3952
|
}
|
|
4731
|
-
const message = response.message || response.Message || errorCode;
|
|
4732
|
-
response.message = message;
|
|
4733
|
-
delete response.Message;
|
|
4734
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4735
3953
|
};
|
|
4736
3954
|
const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
|
|
4737
3955
|
if (output.statusCode !== 204 && output.statusCode >= 300) {
|
|
@@ -4755,35 +3973,19 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
|
|
|
4755
3973
|
switch (errorCode) {
|
|
4756
3974
|
case "BadRequestException":
|
|
4757
3975
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4758
|
-
|
|
4759
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4760
|
-
name: errorCode,
|
|
4761
|
-
$metadata: deserializeMetadata(output),
|
|
4762
|
-
};
|
|
4763
|
-
break;
|
|
3976
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4764
3977
|
case "InternalServerErrorException":
|
|
4765
3978
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4766
|
-
|
|
4767
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4768
|
-
name: errorCode,
|
|
4769
|
-
$metadata: deserializeMetadata(output),
|
|
4770
|
-
};
|
|
4771
|
-
break;
|
|
3979
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4772
3980
|
default:
|
|
4773
3981
|
const parsedBody = parsedOutput.body;
|
|
4774
|
-
|
|
4775
|
-
|
|
4776
|
-
...parsedBody,
|
|
4777
|
-
name: `${errorCode}`,
|
|
4778
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3982
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
3983
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4779
3984
|
$fault: "client",
|
|
4780
3985
|
$metadata: deserializeMetadata(output),
|
|
4781
|
-
};
|
|
3986
|
+
});
|
|
3987
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4782
3988
|
}
|
|
4783
|
-
const message = response.message || response.Message || errorCode;
|
|
4784
|
-
response.message = message;
|
|
4785
|
-
delete response.Message;
|
|
4786
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4787
3989
|
};
|
|
4788
3990
|
const deserializeAws_restJson1UpdateDetectorCommand = async (output, context) => {
|
|
4789
3991
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4807,35 +4009,19 @@ const deserializeAws_restJson1UpdateDetectorCommandError = async (output, contex
|
|
|
4807
4009
|
switch (errorCode) {
|
|
4808
4010
|
case "BadRequestException":
|
|
4809
4011
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4810
|
-
|
|
4811
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4812
|
-
name: errorCode,
|
|
4813
|
-
$metadata: deserializeMetadata(output),
|
|
4814
|
-
};
|
|
4815
|
-
break;
|
|
4012
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4816
4013
|
case "InternalServerErrorException":
|
|
4817
4014
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4818
|
-
|
|
4819
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4820
|
-
name: errorCode,
|
|
4821
|
-
$metadata: deserializeMetadata(output),
|
|
4822
|
-
};
|
|
4823
|
-
break;
|
|
4015
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4824
4016
|
default:
|
|
4825
4017
|
const parsedBody = parsedOutput.body;
|
|
4826
|
-
|
|
4827
|
-
|
|
4828
|
-
...parsedBody,
|
|
4829
|
-
name: `${errorCode}`,
|
|
4830
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4018
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
4019
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4831
4020
|
$fault: "client",
|
|
4832
4021
|
$metadata: deserializeMetadata(output),
|
|
4833
|
-
};
|
|
4022
|
+
});
|
|
4023
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4834
4024
|
}
|
|
4835
|
-
const message = response.message || response.Message || errorCode;
|
|
4836
|
-
response.message = message;
|
|
4837
|
-
delete response.Message;
|
|
4838
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4839
4025
|
};
|
|
4840
4026
|
const deserializeAws_restJson1UpdateFilterCommand = async (output, context) => {
|
|
4841
4027
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4863,35 +4049,19 @@ const deserializeAws_restJson1UpdateFilterCommandError = async (output, context)
|
|
|
4863
4049
|
switch (errorCode) {
|
|
4864
4050
|
case "BadRequestException":
|
|
4865
4051
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4866
|
-
|
|
4867
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4868
|
-
name: errorCode,
|
|
4869
|
-
$metadata: deserializeMetadata(output),
|
|
4870
|
-
};
|
|
4871
|
-
break;
|
|
4052
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4872
4053
|
case "InternalServerErrorException":
|
|
4873
4054
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4874
|
-
|
|
4875
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4876
|
-
name: errorCode,
|
|
4877
|
-
$metadata: deserializeMetadata(output),
|
|
4878
|
-
};
|
|
4879
|
-
break;
|
|
4055
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4880
4056
|
default:
|
|
4881
4057
|
const parsedBody = parsedOutput.body;
|
|
4882
|
-
|
|
4883
|
-
|
|
4884
|
-
...parsedBody,
|
|
4885
|
-
name: `${errorCode}`,
|
|
4886
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4058
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
4059
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4887
4060
|
$fault: "client",
|
|
4888
4061
|
$metadata: deserializeMetadata(output),
|
|
4889
|
-
};
|
|
4062
|
+
});
|
|
4063
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4890
4064
|
}
|
|
4891
|
-
const message = response.message || response.Message || errorCode;
|
|
4892
|
-
response.message = message;
|
|
4893
|
-
delete response.Message;
|
|
4894
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4895
4065
|
};
|
|
4896
4066
|
const deserializeAws_restJson1UpdateFindingsFeedbackCommand = async (output, context) => {
|
|
4897
4067
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4915,35 +4085,19 @@ const deserializeAws_restJson1UpdateFindingsFeedbackCommandError = async (output
|
|
|
4915
4085
|
switch (errorCode) {
|
|
4916
4086
|
case "BadRequestException":
|
|
4917
4087
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4918
|
-
|
|
4919
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4920
|
-
name: errorCode,
|
|
4921
|
-
$metadata: deserializeMetadata(output),
|
|
4922
|
-
};
|
|
4923
|
-
break;
|
|
4088
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4924
4089
|
case "InternalServerErrorException":
|
|
4925
4090
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4926
|
-
|
|
4927
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4928
|
-
name: errorCode,
|
|
4929
|
-
$metadata: deserializeMetadata(output),
|
|
4930
|
-
};
|
|
4931
|
-
break;
|
|
4091
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4932
4092
|
default:
|
|
4933
4093
|
const parsedBody = parsedOutput.body;
|
|
4934
|
-
|
|
4935
|
-
|
|
4936
|
-
...parsedBody,
|
|
4937
|
-
name: `${errorCode}`,
|
|
4938
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4094
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
4095
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4939
4096
|
$fault: "client",
|
|
4940
4097
|
$metadata: deserializeMetadata(output),
|
|
4941
|
-
};
|
|
4098
|
+
});
|
|
4099
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4942
4100
|
}
|
|
4943
|
-
const message = response.message || response.Message || errorCode;
|
|
4944
|
-
response.message = message;
|
|
4945
|
-
delete response.Message;
|
|
4946
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4947
4101
|
};
|
|
4948
4102
|
const deserializeAws_restJson1UpdateIPSetCommand = async (output, context) => {
|
|
4949
4103
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4967,35 +4121,19 @@ const deserializeAws_restJson1UpdateIPSetCommandError = async (output, context)
|
|
|
4967
4121
|
switch (errorCode) {
|
|
4968
4122
|
case "BadRequestException":
|
|
4969
4123
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
4970
|
-
|
|
4971
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4972
|
-
name: errorCode,
|
|
4973
|
-
$metadata: deserializeMetadata(output),
|
|
4974
|
-
};
|
|
4975
|
-
break;
|
|
4124
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4976
4125
|
case "InternalServerErrorException":
|
|
4977
4126
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
4978
|
-
|
|
4979
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4980
|
-
name: errorCode,
|
|
4981
|
-
$metadata: deserializeMetadata(output),
|
|
4982
|
-
};
|
|
4983
|
-
break;
|
|
4127
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4984
4128
|
default:
|
|
4985
4129
|
const parsedBody = parsedOutput.body;
|
|
4986
|
-
|
|
4987
|
-
|
|
4988
|
-
...parsedBody,
|
|
4989
|
-
name: `${errorCode}`,
|
|
4990
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4130
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
4131
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4991
4132
|
$fault: "client",
|
|
4992
4133
|
$metadata: deserializeMetadata(output),
|
|
4993
|
-
};
|
|
4134
|
+
});
|
|
4135
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4994
4136
|
}
|
|
4995
|
-
const message = response.message || response.Message || errorCode;
|
|
4996
|
-
response.message = message;
|
|
4997
|
-
delete response.Message;
|
|
4998
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4999
4137
|
};
|
|
5000
4138
|
const deserializeAws_restJson1UpdateMemberDetectorsCommand = async (output, context) => {
|
|
5001
4139
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5023,35 +4161,19 @@ const deserializeAws_restJson1UpdateMemberDetectorsCommandError = async (output,
|
|
|
5023
4161
|
switch (errorCode) {
|
|
5024
4162
|
case "BadRequestException":
|
|
5025
4163
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
5026
|
-
|
|
5027
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5028
|
-
name: errorCode,
|
|
5029
|
-
$metadata: deserializeMetadata(output),
|
|
5030
|
-
};
|
|
5031
|
-
break;
|
|
4164
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5032
4165
|
case "InternalServerErrorException":
|
|
5033
4166
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
5034
|
-
|
|
5035
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
5036
|
-
name: errorCode,
|
|
5037
|
-
$metadata: deserializeMetadata(output),
|
|
5038
|
-
};
|
|
5039
|
-
break;
|
|
4167
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
5040
4168
|
default:
|
|
5041
4169
|
const parsedBody = parsedOutput.body;
|
|
5042
|
-
|
|
5043
|
-
|
|
5044
|
-
...parsedBody,
|
|
5045
|
-
name: `${errorCode}`,
|
|
5046
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4170
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
4171
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5047
4172
|
$fault: "client",
|
|
5048
4173
|
$metadata: deserializeMetadata(output),
|
|
5049
|
-
};
|
|
4174
|
+
});
|
|
4175
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5050
4176
|
}
|
|
5051
|
-
const message = response.message || response.Message || errorCode;
|
|
5052
|
-
response.message = message;
|
|
5053
|
-
delete response.Message;
|
|
5054
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5055
4177
|
};
|
|
5056
4178
|
const deserializeAws_restJson1UpdateOrganizationConfigurationCommand = async (output, context) => {
|
|
5057
4179
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5075,35 +4197,19 @@ const deserializeAws_restJson1UpdateOrganizationConfigurationCommandError = asyn
|
|
|
5075
4197
|
switch (errorCode) {
|
|
5076
4198
|
case "BadRequestException":
|
|
5077
4199
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
5078
|
-
|
|
5079
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5080
|
-
name: errorCode,
|
|
5081
|
-
$metadata: deserializeMetadata(output),
|
|
5082
|
-
};
|
|
5083
|
-
break;
|
|
4200
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5084
4201
|
case "InternalServerErrorException":
|
|
5085
4202
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
5086
|
-
|
|
5087
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
5088
|
-
name: errorCode,
|
|
5089
|
-
$metadata: deserializeMetadata(output),
|
|
5090
|
-
};
|
|
5091
|
-
break;
|
|
4203
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
5092
4204
|
default:
|
|
5093
4205
|
const parsedBody = parsedOutput.body;
|
|
5094
|
-
|
|
5095
|
-
|
|
5096
|
-
...parsedBody,
|
|
5097
|
-
name: `${errorCode}`,
|
|
5098
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4206
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
4207
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5099
4208
|
$fault: "client",
|
|
5100
4209
|
$metadata: deserializeMetadata(output),
|
|
5101
|
-
};
|
|
4210
|
+
});
|
|
4211
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5102
4212
|
}
|
|
5103
|
-
const message = response.message || response.Message || errorCode;
|
|
5104
|
-
response.message = message;
|
|
5105
|
-
delete response.Message;
|
|
5106
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5107
4213
|
};
|
|
5108
4214
|
const deserializeAws_restJson1UpdatePublishingDestinationCommand = async (output, context) => {
|
|
5109
4215
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5127,35 +4233,19 @@ const deserializeAws_restJson1UpdatePublishingDestinationCommandError = async (o
|
|
|
5127
4233
|
switch (errorCode) {
|
|
5128
4234
|
case "BadRequestException":
|
|
5129
4235
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
5130
|
-
|
|
5131
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5132
|
-
name: errorCode,
|
|
5133
|
-
$metadata: deserializeMetadata(output),
|
|
5134
|
-
};
|
|
5135
|
-
break;
|
|
4236
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5136
4237
|
case "InternalServerErrorException":
|
|
5137
4238
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
5138
|
-
|
|
5139
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
5140
|
-
name: errorCode,
|
|
5141
|
-
$metadata: deserializeMetadata(output),
|
|
5142
|
-
};
|
|
5143
|
-
break;
|
|
4239
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
5144
4240
|
default:
|
|
5145
4241
|
const parsedBody = parsedOutput.body;
|
|
5146
|
-
|
|
5147
|
-
|
|
5148
|
-
...parsedBody,
|
|
5149
|
-
name: `${errorCode}`,
|
|
5150
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4242
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
4243
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5151
4244
|
$fault: "client",
|
|
5152
4245
|
$metadata: deserializeMetadata(output),
|
|
5153
|
-
};
|
|
4246
|
+
});
|
|
4247
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5154
4248
|
}
|
|
5155
|
-
const message = response.message || response.Message || errorCode;
|
|
5156
|
-
response.message = message;
|
|
5157
|
-
delete response.Message;
|
|
5158
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5159
4249
|
};
|
|
5160
4250
|
const deserializeAws_restJson1UpdateThreatIntelSetCommand = async (output, context) => {
|
|
5161
4251
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5179,44 +4269,22 @@ const deserializeAws_restJson1UpdateThreatIntelSetCommandError = async (output,
|
|
|
5179
4269
|
switch (errorCode) {
|
|
5180
4270
|
case "BadRequestException":
|
|
5181
4271
|
case "com.amazonaws.guardduty#BadRequestException":
|
|
5182
|
-
|
|
5183
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5184
|
-
name: errorCode,
|
|
5185
|
-
$metadata: deserializeMetadata(output),
|
|
5186
|
-
};
|
|
5187
|
-
break;
|
|
4272
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5188
4273
|
case "InternalServerErrorException":
|
|
5189
4274
|
case "com.amazonaws.guardduty#InternalServerErrorException":
|
|
5190
|
-
|
|
5191
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
5192
|
-
name: errorCode,
|
|
5193
|
-
$metadata: deserializeMetadata(output),
|
|
5194
|
-
};
|
|
5195
|
-
break;
|
|
4275
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
5196
4276
|
default:
|
|
5197
4277
|
const parsedBody = parsedOutput.body;
|
|
5198
|
-
|
|
5199
|
-
|
|
5200
|
-
...parsedBody,
|
|
5201
|
-
name: `${errorCode}`,
|
|
5202
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4278
|
+
response = new GuardDutyServiceException_1.GuardDutyServiceException({
|
|
4279
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5203
4280
|
$fault: "client",
|
|
5204
4281
|
$metadata: deserializeMetadata(output),
|
|
5205
|
-
};
|
|
4282
|
+
});
|
|
4283
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5206
4284
|
}
|
|
5207
|
-
const message = response.message || response.Message || errorCode;
|
|
5208
|
-
response.message = message;
|
|
5209
|
-
delete response.Message;
|
|
5210
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5211
4285
|
};
|
|
5212
4286
|
const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput, context) => {
|
|
5213
|
-
const contents = {
|
|
5214
|
-
name: "BadRequestException",
|
|
5215
|
-
$fault: "client",
|
|
5216
|
-
$metadata: deserializeMetadata(parsedOutput),
|
|
5217
|
-
Message: undefined,
|
|
5218
|
-
Type: undefined,
|
|
5219
|
-
};
|
|
4287
|
+
const contents = {};
|
|
5220
4288
|
const data = parsedOutput.body;
|
|
5221
4289
|
if (data.message !== undefined && data.message !== null) {
|
|
5222
4290
|
contents.Message = smithy_client_1.expectString(data.message);
|
|
@@ -5224,16 +4292,14 @@ const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput,
|
|
|
5224
4292
|
if (data.__type !== undefined && data.__type !== null) {
|
|
5225
4293
|
contents.Type = smithy_client_1.expectString(data.__type);
|
|
5226
4294
|
}
|
|
5227
|
-
|
|
4295
|
+
const exception = new models_0_1.BadRequestException({
|
|
4296
|
+
$metadata: deserializeMetadata(parsedOutput),
|
|
4297
|
+
...contents,
|
|
4298
|
+
});
|
|
4299
|
+
return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
|
|
5228
4300
|
};
|
|
5229
4301
|
const deserializeAws_restJson1InternalServerErrorExceptionResponse = async (parsedOutput, context) => {
|
|
5230
|
-
const contents = {
|
|
5231
|
-
name: "InternalServerErrorException",
|
|
5232
|
-
$fault: "server",
|
|
5233
|
-
$metadata: deserializeMetadata(parsedOutput),
|
|
5234
|
-
Message: undefined,
|
|
5235
|
-
Type: undefined,
|
|
5236
|
-
};
|
|
4302
|
+
const contents = {};
|
|
5237
4303
|
const data = parsedOutput.body;
|
|
5238
4304
|
if (data.message !== undefined && data.message !== null) {
|
|
5239
4305
|
contents.Message = smithy_client_1.expectString(data.message);
|
|
@@ -5241,7 +4307,11 @@ const deserializeAws_restJson1InternalServerErrorExceptionResponse = async (pars
|
|
|
5241
4307
|
if (data.__type !== undefined && data.__type !== null) {
|
|
5242
4308
|
contents.Type = smithy_client_1.expectString(data.__type);
|
|
5243
4309
|
}
|
|
5244
|
-
|
|
4310
|
+
const exception = new models_0_1.InternalServerErrorException({
|
|
4311
|
+
$metadata: deserializeMetadata(parsedOutput),
|
|
4312
|
+
...contents,
|
|
4313
|
+
});
|
|
4314
|
+
return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
|
|
5245
4315
|
};
|
|
5246
4316
|
const serializeAws_restJson1AccountDetail = (input, context) => {
|
|
5247
4317
|
return {
|
|
@@ -5536,7 +4606,7 @@ const deserializeAws_restJson1AdminAccount = (output, context) => {
|
|
|
5536
4606
|
};
|
|
5537
4607
|
};
|
|
5538
4608
|
const deserializeAws_restJson1AdminAccounts = (output, context) => {
|
|
5539
|
-
|
|
4609
|
+
const retVal = (output || [])
|
|
5540
4610
|
.filter((e) => e != null)
|
|
5541
4611
|
.map((entry) => {
|
|
5542
4612
|
if (entry === null) {
|
|
@@ -5544,6 +4614,7 @@ const deserializeAws_restJson1AdminAccounts = (output, context) => {
|
|
|
5544
4614
|
}
|
|
5545
4615
|
return deserializeAws_restJson1AdminAccount(entry, context);
|
|
5546
4616
|
});
|
|
4617
|
+
return retVal;
|
|
5547
4618
|
};
|
|
5548
4619
|
const deserializeAws_restJson1AwsApiCallAction = (output, context) => {
|
|
5549
4620
|
return {
|
|
@@ -5636,7 +4707,7 @@ const deserializeAws_restJson1Container = (output, context) => {
|
|
|
5636
4707
|
};
|
|
5637
4708
|
};
|
|
5638
4709
|
const deserializeAws_restJson1Containers = (output, context) => {
|
|
5639
|
-
|
|
4710
|
+
const retVal = (output || [])
|
|
5640
4711
|
.filter((e) => e != null)
|
|
5641
4712
|
.map((entry) => {
|
|
5642
4713
|
if (entry === null) {
|
|
@@ -5644,6 +4715,7 @@ const deserializeAws_restJson1Containers = (output, context) => {
|
|
|
5644
4715
|
}
|
|
5645
4716
|
return deserializeAws_restJson1Container(entry, context);
|
|
5646
4717
|
});
|
|
4718
|
+
return retVal;
|
|
5647
4719
|
};
|
|
5648
4720
|
const deserializeAws_restJson1CountBySeverity = (output, context) => {
|
|
5649
4721
|
return Object.entries(output).reduce((acc, [key, value]) => {
|
|
@@ -5712,7 +4784,7 @@ const deserializeAws_restJson1DestinationProperties = (output, context) => {
|
|
|
5712
4784
|
};
|
|
5713
4785
|
};
|
|
5714
4786
|
const deserializeAws_restJson1Destinations = (output, context) => {
|
|
5715
|
-
|
|
4787
|
+
const retVal = (output || [])
|
|
5716
4788
|
.filter((e) => e != null)
|
|
5717
4789
|
.map((entry) => {
|
|
5718
4790
|
if (entry === null) {
|
|
@@ -5720,9 +4792,10 @@ const deserializeAws_restJson1Destinations = (output, context) => {
|
|
|
5720
4792
|
}
|
|
5721
4793
|
return deserializeAws_restJson1Destination(entry, context);
|
|
5722
4794
|
});
|
|
4795
|
+
return retVal;
|
|
5723
4796
|
};
|
|
5724
4797
|
const deserializeAws_restJson1DetectorIds = (output, context) => {
|
|
5725
|
-
|
|
4798
|
+
const retVal = (output || [])
|
|
5726
4799
|
.filter((e) => e != null)
|
|
5727
4800
|
.map((entry) => {
|
|
5728
4801
|
if (entry === null) {
|
|
@@ -5730,6 +4803,7 @@ const deserializeAws_restJson1DetectorIds = (output, context) => {
|
|
|
5730
4803
|
}
|
|
5731
4804
|
return smithy_client_1.expectString(entry);
|
|
5732
4805
|
});
|
|
4806
|
+
return retVal;
|
|
5733
4807
|
};
|
|
5734
4808
|
const deserializeAws_restJson1DNSLogsConfigurationResult = (output, context) => {
|
|
5735
4809
|
return {
|
|
@@ -5761,7 +4835,7 @@ const deserializeAws_restJson1EksClusterDetails = (output, context) => {
|
|
|
5761
4835
|
};
|
|
5762
4836
|
};
|
|
5763
4837
|
const deserializeAws_restJson1Eq = (output, context) => {
|
|
5764
|
-
|
|
4838
|
+
const retVal = (output || [])
|
|
5765
4839
|
.filter((e) => e != null)
|
|
5766
4840
|
.map((entry) => {
|
|
5767
4841
|
if (entry === null) {
|
|
@@ -5769,9 +4843,10 @@ const deserializeAws_restJson1Eq = (output, context) => {
|
|
|
5769
4843
|
}
|
|
5770
4844
|
return smithy_client_1.expectString(entry);
|
|
5771
4845
|
});
|
|
4846
|
+
return retVal;
|
|
5772
4847
|
};
|
|
5773
4848
|
const deserializeAws_restJson1Equals = (output, context) => {
|
|
5774
|
-
|
|
4849
|
+
const retVal = (output || [])
|
|
5775
4850
|
.filter((e) => e != null)
|
|
5776
4851
|
.map((entry) => {
|
|
5777
4852
|
if (entry === null) {
|
|
@@ -5779,6 +4854,7 @@ const deserializeAws_restJson1Equals = (output, context) => {
|
|
|
5779
4854
|
}
|
|
5780
4855
|
return smithy_client_1.expectString(entry);
|
|
5781
4856
|
});
|
|
4857
|
+
return retVal;
|
|
5782
4858
|
};
|
|
5783
4859
|
const deserializeAws_restJson1Evidence = (output, context) => {
|
|
5784
4860
|
return {
|
|
@@ -5788,7 +4864,7 @@ const deserializeAws_restJson1Evidence = (output, context) => {
|
|
|
5788
4864
|
};
|
|
5789
4865
|
};
|
|
5790
4866
|
const deserializeAws_restJson1FilterNames = (output, context) => {
|
|
5791
|
-
|
|
4867
|
+
const retVal = (output || [])
|
|
5792
4868
|
.filter((e) => e != null)
|
|
5793
4869
|
.map((entry) => {
|
|
5794
4870
|
if (entry === null) {
|
|
@@ -5796,6 +4872,7 @@ const deserializeAws_restJson1FilterNames = (output, context) => {
|
|
|
5796
4872
|
}
|
|
5797
4873
|
return smithy_client_1.expectString(entry);
|
|
5798
4874
|
});
|
|
4875
|
+
return retVal;
|
|
5799
4876
|
};
|
|
5800
4877
|
const deserializeAws_restJson1Finding = (output, context) => {
|
|
5801
4878
|
return {
|
|
@@ -5828,7 +4905,7 @@ const deserializeAws_restJson1FindingCriteria = (output, context) => {
|
|
|
5828
4905
|
};
|
|
5829
4906
|
};
|
|
5830
4907
|
const deserializeAws_restJson1FindingIds = (output, context) => {
|
|
5831
|
-
|
|
4908
|
+
const retVal = (output || [])
|
|
5832
4909
|
.filter((e) => e != null)
|
|
5833
4910
|
.map((entry) => {
|
|
5834
4911
|
if (entry === null) {
|
|
@@ -5836,9 +4913,10 @@ const deserializeAws_restJson1FindingIds = (output, context) => {
|
|
|
5836
4913
|
}
|
|
5837
4914
|
return smithy_client_1.expectString(entry);
|
|
5838
4915
|
});
|
|
4916
|
+
return retVal;
|
|
5839
4917
|
};
|
|
5840
4918
|
const deserializeAws_restJson1Findings = (output, context) => {
|
|
5841
|
-
|
|
4919
|
+
const retVal = (output || [])
|
|
5842
4920
|
.filter((e) => e != null)
|
|
5843
4921
|
.map((entry) => {
|
|
5844
4922
|
if (entry === null) {
|
|
@@ -5846,6 +4924,7 @@ const deserializeAws_restJson1Findings = (output, context) => {
|
|
|
5846
4924
|
}
|
|
5847
4925
|
return deserializeAws_restJson1Finding(entry, context);
|
|
5848
4926
|
});
|
|
4927
|
+
return retVal;
|
|
5849
4928
|
};
|
|
5850
4929
|
const deserializeAws_restJson1FindingStatistics = (output, context) => {
|
|
5851
4930
|
return {
|
|
@@ -5866,7 +4945,7 @@ const deserializeAws_restJson1GeoLocation = (output, context) => {
|
|
|
5866
4945
|
};
|
|
5867
4946
|
};
|
|
5868
4947
|
const deserializeAws_restJson1Groups = (output, context) => {
|
|
5869
|
-
|
|
4948
|
+
const retVal = (output || [])
|
|
5870
4949
|
.filter((e) => e != null)
|
|
5871
4950
|
.map((entry) => {
|
|
5872
4951
|
if (entry === null) {
|
|
@@ -5874,6 +4953,7 @@ const deserializeAws_restJson1Groups = (output, context) => {
|
|
|
5874
4953
|
}
|
|
5875
4954
|
return smithy_client_1.expectString(entry);
|
|
5876
4955
|
});
|
|
4956
|
+
return retVal;
|
|
5877
4957
|
};
|
|
5878
4958
|
const deserializeAws_restJson1HostPath = (output, context) => {
|
|
5879
4959
|
return {
|
|
@@ -5920,7 +5000,7 @@ const deserializeAws_restJson1Invitation = (output, context) => {
|
|
|
5920
5000
|
};
|
|
5921
5001
|
};
|
|
5922
5002
|
const deserializeAws_restJson1Invitations = (output, context) => {
|
|
5923
|
-
|
|
5003
|
+
const retVal = (output || [])
|
|
5924
5004
|
.filter((e) => e != null)
|
|
5925
5005
|
.map((entry) => {
|
|
5926
5006
|
if (entry === null) {
|
|
@@ -5928,9 +5008,10 @@ const deserializeAws_restJson1Invitations = (output, context) => {
|
|
|
5928
5008
|
}
|
|
5929
5009
|
return deserializeAws_restJson1Invitation(entry, context);
|
|
5930
5010
|
});
|
|
5011
|
+
return retVal;
|
|
5931
5012
|
};
|
|
5932
5013
|
const deserializeAws_restJson1IpSetIds = (output, context) => {
|
|
5933
|
-
|
|
5014
|
+
const retVal = (output || [])
|
|
5934
5015
|
.filter((e) => e != null)
|
|
5935
5016
|
.map((entry) => {
|
|
5936
5017
|
if (entry === null) {
|
|
@@ -5938,9 +5019,10 @@ const deserializeAws_restJson1IpSetIds = (output, context) => {
|
|
|
5938
5019
|
}
|
|
5939
5020
|
return smithy_client_1.expectString(entry);
|
|
5940
5021
|
});
|
|
5022
|
+
return retVal;
|
|
5941
5023
|
};
|
|
5942
5024
|
const deserializeAws_restJson1Ipv6Addresses = (output, context) => {
|
|
5943
|
-
|
|
5025
|
+
const retVal = (output || [])
|
|
5944
5026
|
.filter((e) => e != null)
|
|
5945
5027
|
.map((entry) => {
|
|
5946
5028
|
if (entry === null) {
|
|
@@ -5948,6 +5030,7 @@ const deserializeAws_restJson1Ipv6Addresses = (output, context) => {
|
|
|
5948
5030
|
}
|
|
5949
5031
|
return smithy_client_1.expectString(entry);
|
|
5950
5032
|
});
|
|
5033
|
+
return retVal;
|
|
5951
5034
|
};
|
|
5952
5035
|
const deserializeAws_restJson1KubernetesApiCallAction = (output, context) => {
|
|
5953
5036
|
return {
|
|
@@ -6049,7 +5132,7 @@ const deserializeAws_restJson1MemberDataSourceConfiguration = (output, context)
|
|
|
6049
5132
|
};
|
|
6050
5133
|
};
|
|
6051
5134
|
const deserializeAws_restJson1MemberDataSourceConfigurations = (output, context) => {
|
|
6052
|
-
|
|
5135
|
+
const retVal = (output || [])
|
|
6053
5136
|
.filter((e) => e != null)
|
|
6054
5137
|
.map((entry) => {
|
|
6055
5138
|
if (entry === null) {
|
|
@@ -6057,9 +5140,10 @@ const deserializeAws_restJson1MemberDataSourceConfigurations = (output, context)
|
|
|
6057
5140
|
}
|
|
6058
5141
|
return deserializeAws_restJson1MemberDataSourceConfiguration(entry, context);
|
|
6059
5142
|
});
|
|
5143
|
+
return retVal;
|
|
6060
5144
|
};
|
|
6061
5145
|
const deserializeAws_restJson1Members = (output, context) => {
|
|
6062
|
-
|
|
5146
|
+
const retVal = (output || [])
|
|
6063
5147
|
.filter((e) => e != null)
|
|
6064
5148
|
.map((entry) => {
|
|
6065
5149
|
if (entry === null) {
|
|
@@ -6067,9 +5151,10 @@ const deserializeAws_restJson1Members = (output, context) => {
|
|
|
6067
5151
|
}
|
|
6068
5152
|
return deserializeAws_restJson1Member(entry, context);
|
|
6069
5153
|
});
|
|
5154
|
+
return retVal;
|
|
6070
5155
|
};
|
|
6071
5156
|
const deserializeAws_restJson1Neq = (output, context) => {
|
|
6072
|
-
|
|
5157
|
+
const retVal = (output || [])
|
|
6073
5158
|
.filter((e) => e != null)
|
|
6074
5159
|
.map((entry) => {
|
|
6075
5160
|
if (entry === null) {
|
|
@@ -6077,6 +5162,7 @@ const deserializeAws_restJson1Neq = (output, context) => {
|
|
|
6077
5162
|
}
|
|
6078
5163
|
return smithy_client_1.expectString(entry);
|
|
6079
5164
|
});
|
|
5165
|
+
return retVal;
|
|
6080
5166
|
};
|
|
6081
5167
|
const deserializeAws_restJson1NetworkConnectionAction = (output, context) => {
|
|
6082
5168
|
return {
|
|
@@ -6118,7 +5204,7 @@ const deserializeAws_restJson1NetworkInterface = (output, context) => {
|
|
|
6118
5204
|
};
|
|
6119
5205
|
};
|
|
6120
5206
|
const deserializeAws_restJson1NetworkInterfaces = (output, context) => {
|
|
6121
|
-
|
|
5207
|
+
const retVal = (output || [])
|
|
6122
5208
|
.filter((e) => e != null)
|
|
6123
5209
|
.map((entry) => {
|
|
6124
5210
|
if (entry === null) {
|
|
@@ -6126,9 +5212,10 @@ const deserializeAws_restJson1NetworkInterfaces = (output, context) => {
|
|
|
6126
5212
|
}
|
|
6127
5213
|
return deserializeAws_restJson1NetworkInterface(entry, context);
|
|
6128
5214
|
});
|
|
5215
|
+
return retVal;
|
|
6129
5216
|
};
|
|
6130
5217
|
const deserializeAws_restJson1NotEquals = (output, context) => {
|
|
6131
|
-
|
|
5218
|
+
const retVal = (output || [])
|
|
6132
5219
|
.filter((e) => e != null)
|
|
6133
5220
|
.map((entry) => {
|
|
6134
5221
|
if (entry === null) {
|
|
@@ -6136,6 +5223,7 @@ const deserializeAws_restJson1NotEquals = (output, context) => {
|
|
|
6136
5223
|
}
|
|
6137
5224
|
return smithy_client_1.expectString(entry);
|
|
6138
5225
|
});
|
|
5226
|
+
return retVal;
|
|
6139
5227
|
};
|
|
6140
5228
|
const deserializeAws_restJson1Organization = (output, context) => {
|
|
6141
5229
|
return {
|
|
@@ -6209,7 +5297,7 @@ const deserializeAws_restJson1PortProbeDetail = (output, context) => {
|
|
|
6209
5297
|
};
|
|
6210
5298
|
};
|
|
6211
5299
|
const deserializeAws_restJson1PortProbeDetails = (output, context) => {
|
|
6212
|
-
|
|
5300
|
+
const retVal = (output || [])
|
|
6213
5301
|
.filter((e) => e != null)
|
|
6214
5302
|
.map((entry) => {
|
|
6215
5303
|
if (entry === null) {
|
|
@@ -6217,6 +5305,7 @@ const deserializeAws_restJson1PortProbeDetails = (output, context) => {
|
|
|
6217
5305
|
}
|
|
6218
5306
|
return deserializeAws_restJson1PortProbeDetail(entry, context);
|
|
6219
5307
|
});
|
|
5308
|
+
return retVal;
|
|
6220
5309
|
};
|
|
6221
5310
|
const deserializeAws_restJson1PrivateIpAddressDetails = (output, context) => {
|
|
6222
5311
|
return {
|
|
@@ -6225,7 +5314,7 @@ const deserializeAws_restJson1PrivateIpAddressDetails = (output, context) => {
|
|
|
6225
5314
|
};
|
|
6226
5315
|
};
|
|
6227
5316
|
const deserializeAws_restJson1PrivateIpAddresses = (output, context) => {
|
|
6228
|
-
|
|
5317
|
+
const retVal = (output || [])
|
|
6229
5318
|
.filter((e) => e != null)
|
|
6230
5319
|
.map((entry) => {
|
|
6231
5320
|
if (entry === null) {
|
|
@@ -6233,6 +5322,7 @@ const deserializeAws_restJson1PrivateIpAddresses = (output, context) => {
|
|
|
6233
5322
|
}
|
|
6234
5323
|
return deserializeAws_restJson1PrivateIpAddressDetails(entry, context);
|
|
6235
5324
|
});
|
|
5325
|
+
return retVal;
|
|
6236
5326
|
};
|
|
6237
5327
|
const deserializeAws_restJson1ProductCode = (output, context) => {
|
|
6238
5328
|
return {
|
|
@@ -6241,7 +5331,7 @@ const deserializeAws_restJson1ProductCode = (output, context) => {
|
|
|
6241
5331
|
};
|
|
6242
5332
|
};
|
|
6243
5333
|
const deserializeAws_restJson1ProductCodes = (output, context) => {
|
|
6244
|
-
|
|
5334
|
+
const retVal = (output || [])
|
|
6245
5335
|
.filter((e) => e != null)
|
|
6246
5336
|
.map((entry) => {
|
|
6247
5337
|
if (entry === null) {
|
|
@@ -6249,6 +5339,7 @@ const deserializeAws_restJson1ProductCodes = (output, context) => {
|
|
|
6249
5339
|
}
|
|
6250
5340
|
return deserializeAws_restJson1ProductCode(entry, context);
|
|
6251
5341
|
});
|
|
5342
|
+
return retVal;
|
|
6252
5343
|
};
|
|
6253
5344
|
const deserializeAws_restJson1PublicAccess = (output, context) => {
|
|
6254
5345
|
return {
|
|
@@ -6330,7 +5421,7 @@ const deserializeAws_restJson1S3BucketDetail = (output, context) => {
|
|
|
6330
5421
|
};
|
|
6331
5422
|
};
|
|
6332
5423
|
const deserializeAws_restJson1S3BucketDetails = (output, context) => {
|
|
6333
|
-
|
|
5424
|
+
const retVal = (output || [])
|
|
6334
5425
|
.filter((e) => e != null)
|
|
6335
5426
|
.map((entry) => {
|
|
6336
5427
|
if (entry === null) {
|
|
@@ -6338,6 +5429,7 @@ const deserializeAws_restJson1S3BucketDetails = (output, context) => {
|
|
|
6338
5429
|
}
|
|
6339
5430
|
return deserializeAws_restJson1S3BucketDetail(entry, context);
|
|
6340
5431
|
});
|
|
5432
|
+
return retVal;
|
|
6341
5433
|
};
|
|
6342
5434
|
const deserializeAws_restJson1S3LogsConfigurationResult = (output, context) => {
|
|
6343
5435
|
return {
|
|
@@ -6356,7 +5448,7 @@ const deserializeAws_restJson1SecurityGroup = (output, context) => {
|
|
|
6356
5448
|
};
|
|
6357
5449
|
};
|
|
6358
5450
|
const deserializeAws_restJson1SecurityGroups = (output, context) => {
|
|
6359
|
-
|
|
5451
|
+
const retVal = (output || [])
|
|
6360
5452
|
.filter((e) => e != null)
|
|
6361
5453
|
.map((entry) => {
|
|
6362
5454
|
if (entry === null) {
|
|
@@ -6364,6 +5456,7 @@ const deserializeAws_restJson1SecurityGroups = (output, context) => {
|
|
|
6364
5456
|
}
|
|
6365
5457
|
return deserializeAws_restJson1SecurityGroup(entry, context);
|
|
6366
5458
|
});
|
|
5459
|
+
return retVal;
|
|
6367
5460
|
};
|
|
6368
5461
|
const deserializeAws_restJson1Service = (output, context) => {
|
|
6369
5462
|
return {
|
|
@@ -6384,7 +5477,7 @@ const deserializeAws_restJson1Service = (output, context) => {
|
|
|
6384
5477
|
};
|
|
6385
5478
|
};
|
|
6386
5479
|
const deserializeAws_restJson1SourceIps = (output, context) => {
|
|
6387
|
-
|
|
5480
|
+
const retVal = (output || [])
|
|
6388
5481
|
.filter((e) => e != null)
|
|
6389
5482
|
.map((entry) => {
|
|
6390
5483
|
if (entry === null) {
|
|
@@ -6392,6 +5485,7 @@ const deserializeAws_restJson1SourceIps = (output, context) => {
|
|
|
6392
5485
|
}
|
|
6393
5486
|
return smithy_client_1.expectString(entry);
|
|
6394
5487
|
});
|
|
5488
|
+
return retVal;
|
|
6395
5489
|
};
|
|
6396
5490
|
const deserializeAws_restJson1Tag = (output, context) => {
|
|
6397
5491
|
return {
|
|
@@ -6411,7 +5505,7 @@ const deserializeAws_restJson1TagMap = (output, context) => {
|
|
|
6411
5505
|
}, {});
|
|
6412
5506
|
};
|
|
6413
5507
|
const deserializeAws_restJson1Tags = (output, context) => {
|
|
6414
|
-
|
|
5508
|
+
const retVal = (output || [])
|
|
6415
5509
|
.filter((e) => e != null)
|
|
6416
5510
|
.map((entry) => {
|
|
6417
5511
|
if (entry === null) {
|
|
@@ -6419,6 +5513,7 @@ const deserializeAws_restJson1Tags = (output, context) => {
|
|
|
6419
5513
|
}
|
|
6420
5514
|
return deserializeAws_restJson1Tag(entry, context);
|
|
6421
5515
|
});
|
|
5516
|
+
return retVal;
|
|
6422
5517
|
};
|
|
6423
5518
|
const deserializeAws_restJson1ThreatIntelligenceDetail = (output, context) => {
|
|
6424
5519
|
return {
|
|
@@ -6429,7 +5524,7 @@ const deserializeAws_restJson1ThreatIntelligenceDetail = (output, context) => {
|
|
|
6429
5524
|
};
|
|
6430
5525
|
};
|
|
6431
5526
|
const deserializeAws_restJson1ThreatIntelligenceDetails = (output, context) => {
|
|
6432
|
-
|
|
5527
|
+
const retVal = (output || [])
|
|
6433
5528
|
.filter((e) => e != null)
|
|
6434
5529
|
.map((entry) => {
|
|
6435
5530
|
if (entry === null) {
|
|
@@ -6437,9 +5532,10 @@ const deserializeAws_restJson1ThreatIntelligenceDetails = (output, context) => {
|
|
|
6437
5532
|
}
|
|
6438
5533
|
return deserializeAws_restJson1ThreatIntelligenceDetail(entry, context);
|
|
6439
5534
|
});
|
|
5535
|
+
return retVal;
|
|
6440
5536
|
};
|
|
6441
5537
|
const deserializeAws_restJson1ThreatIntelSetIds = (output, context) => {
|
|
6442
|
-
|
|
5538
|
+
const retVal = (output || [])
|
|
6443
5539
|
.filter((e) => e != null)
|
|
6444
5540
|
.map((entry) => {
|
|
6445
5541
|
if (entry === null) {
|
|
@@ -6447,9 +5543,10 @@ const deserializeAws_restJson1ThreatIntelSetIds = (output, context) => {
|
|
|
6447
5543
|
}
|
|
6448
5544
|
return smithy_client_1.expectString(entry);
|
|
6449
5545
|
});
|
|
5546
|
+
return retVal;
|
|
6450
5547
|
};
|
|
6451
5548
|
const deserializeAws_restJson1ThreatNames = (output, context) => {
|
|
6452
|
-
|
|
5549
|
+
const retVal = (output || [])
|
|
6453
5550
|
.filter((e) => e != null)
|
|
6454
5551
|
.map((entry) => {
|
|
6455
5552
|
if (entry === null) {
|
|
@@ -6457,6 +5554,7 @@ const deserializeAws_restJson1ThreatNames = (output, context) => {
|
|
|
6457
5554
|
}
|
|
6458
5555
|
return smithy_client_1.expectString(entry);
|
|
6459
5556
|
});
|
|
5557
|
+
return retVal;
|
|
6460
5558
|
};
|
|
6461
5559
|
const deserializeAws_restJson1Total = (output, context) => {
|
|
6462
5560
|
return {
|
|
@@ -6471,7 +5569,7 @@ const deserializeAws_restJson1UnprocessedAccount = (output, context) => {
|
|
|
6471
5569
|
};
|
|
6472
5570
|
};
|
|
6473
5571
|
const deserializeAws_restJson1UnprocessedAccounts = (output, context) => {
|
|
6474
|
-
|
|
5572
|
+
const retVal = (output || [])
|
|
6475
5573
|
.filter((e) => e != null)
|
|
6476
5574
|
.map((entry) => {
|
|
6477
5575
|
if (entry === null) {
|
|
@@ -6479,6 +5577,7 @@ const deserializeAws_restJson1UnprocessedAccounts = (output, context) => {
|
|
|
6479
5577
|
}
|
|
6480
5578
|
return deserializeAws_restJson1UnprocessedAccount(entry, context);
|
|
6481
5579
|
});
|
|
5580
|
+
return retVal;
|
|
6482
5581
|
};
|
|
6483
5582
|
const deserializeAws_restJson1UsageAccountResult = (output, context) => {
|
|
6484
5583
|
return {
|
|
@@ -6489,7 +5588,7 @@ const deserializeAws_restJson1UsageAccountResult = (output, context) => {
|
|
|
6489
5588
|
};
|
|
6490
5589
|
};
|
|
6491
5590
|
const deserializeAws_restJson1UsageAccountResultList = (output, context) => {
|
|
6492
|
-
|
|
5591
|
+
const retVal = (output || [])
|
|
6493
5592
|
.filter((e) => e != null)
|
|
6494
5593
|
.map((entry) => {
|
|
6495
5594
|
if (entry === null) {
|
|
@@ -6497,6 +5596,7 @@ const deserializeAws_restJson1UsageAccountResultList = (output, context) => {
|
|
|
6497
5596
|
}
|
|
6498
5597
|
return deserializeAws_restJson1UsageAccountResult(entry, context);
|
|
6499
5598
|
});
|
|
5599
|
+
return retVal;
|
|
6500
5600
|
};
|
|
6501
5601
|
const deserializeAws_restJson1UsageDataSourceResult = (output, context) => {
|
|
6502
5602
|
return {
|
|
@@ -6507,7 +5607,7 @@ const deserializeAws_restJson1UsageDataSourceResult = (output, context) => {
|
|
|
6507
5607
|
};
|
|
6508
5608
|
};
|
|
6509
5609
|
const deserializeAws_restJson1UsageDataSourceResultList = (output, context) => {
|
|
6510
|
-
|
|
5610
|
+
const retVal = (output || [])
|
|
6511
5611
|
.filter((e) => e != null)
|
|
6512
5612
|
.map((entry) => {
|
|
6513
5613
|
if (entry === null) {
|
|
@@ -6515,6 +5615,7 @@ const deserializeAws_restJson1UsageDataSourceResultList = (output, context) => {
|
|
|
6515
5615
|
}
|
|
6516
5616
|
return deserializeAws_restJson1UsageDataSourceResult(entry, context);
|
|
6517
5617
|
});
|
|
5618
|
+
return retVal;
|
|
6518
5619
|
};
|
|
6519
5620
|
const deserializeAws_restJson1UsageResourceResult = (output, context) => {
|
|
6520
5621
|
return {
|
|
@@ -6525,7 +5626,7 @@ const deserializeAws_restJson1UsageResourceResult = (output, context) => {
|
|
|
6525
5626
|
};
|
|
6526
5627
|
};
|
|
6527
5628
|
const deserializeAws_restJson1UsageResourceResultList = (output, context) => {
|
|
6528
|
-
|
|
5629
|
+
const retVal = (output || [])
|
|
6529
5630
|
.filter((e) => e != null)
|
|
6530
5631
|
.map((entry) => {
|
|
6531
5632
|
if (entry === null) {
|
|
@@ -6533,6 +5634,7 @@ const deserializeAws_restJson1UsageResourceResultList = (output, context) => {
|
|
|
6533
5634
|
}
|
|
6534
5635
|
return deserializeAws_restJson1UsageResourceResult(entry, context);
|
|
6535
5636
|
});
|
|
5637
|
+
return retVal;
|
|
6536
5638
|
};
|
|
6537
5639
|
const deserializeAws_restJson1UsageStatistics = (output, context) => {
|
|
6538
5640
|
return {
|
|
@@ -6565,7 +5667,7 @@ const deserializeAws_restJson1VolumeMount = (output, context) => {
|
|
|
6565
5667
|
};
|
|
6566
5668
|
};
|
|
6567
5669
|
const deserializeAws_restJson1VolumeMounts = (output, context) => {
|
|
6568
|
-
|
|
5670
|
+
const retVal = (output || [])
|
|
6569
5671
|
.filter((e) => e != null)
|
|
6570
5672
|
.map((entry) => {
|
|
6571
5673
|
if (entry === null) {
|
|
@@ -6573,9 +5675,10 @@ const deserializeAws_restJson1VolumeMounts = (output, context) => {
|
|
|
6573
5675
|
}
|
|
6574
5676
|
return deserializeAws_restJson1VolumeMount(entry, context);
|
|
6575
5677
|
});
|
|
5678
|
+
return retVal;
|
|
6576
5679
|
};
|
|
6577
5680
|
const deserializeAws_restJson1Volumes = (output, context) => {
|
|
6578
|
-
|
|
5681
|
+
const retVal = (output || [])
|
|
6579
5682
|
.filter((e) => e != null)
|
|
6580
5683
|
.map((entry) => {
|
|
6581
5684
|
if (entry === null) {
|
|
@@ -6583,6 +5686,7 @@ const deserializeAws_restJson1Volumes = (output, context) => {
|
|
|
6583
5686
|
}
|
|
6584
5687
|
return deserializeAws_restJson1Volume(entry, context);
|
|
6585
5688
|
});
|
|
5689
|
+
return retVal;
|
|
6586
5690
|
};
|
|
6587
5691
|
const deserializeMetadata = (output) => {
|
|
6588
5692
|
var _a;
|