@aws-sdk/client-waf 3.312.0 → 3.315.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist-cjs/protocols/Aws_json1_1.js +389 -2260
  2. package/dist-es/protocols/Aws_json1_1.js +390 -2261
  3. package/package.json +6 -6
package/dist-es/protocols/Aws_json1_1.js CHANGED
@@ -1,245 +1,245 @@
1
1
  import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
2
- import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, throwDefaultError, } from "@aws-sdk/smithy-client";
2
+ import { _json, decorateServiceException as __decorateServiceException, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@aws-sdk/smithy-client";
3
3
  import { WAFBadRequestException, WAFDisallowedNameException, WAFEntityMigrationException, WAFInternalErrorException, WAFInvalidAccountException, WAFInvalidOperationException, WAFInvalidParameterException, WAFInvalidPermissionPolicyException, WAFInvalidRegexPatternException, WAFLimitsExceededException, WAFNonEmptyEntityException, WAFNonexistentContainerException, WAFNonexistentItemException, WAFReferencedItemException, WAFServiceLinkedRoleErrorException, WAFStaleDataException, WAFSubscriptionNotFoundException, WAFTagOperationException, WAFTagOperationInternalErrorException, } from "../models/models_0";
4
4
  import { WAFServiceException as __BaseException } from "../models/WAFServiceException";
5
5
  export const se_CreateByteMatchSetCommand = async (input, context) => {
6
6
  const headers = sharedHeaders("CreateByteMatchSet");
7
7
  let body;
8
- body = JSON.stringify(se_CreateByteMatchSetRequest(input, context));
8
+ body = JSON.stringify(_json(input));
9
9
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
10
10
  };
11
11
  export const se_CreateGeoMatchSetCommand = async (input, context) => {
12
12
  const headers = sharedHeaders("CreateGeoMatchSet");
13
13
  let body;
14
- body = JSON.stringify(se_CreateGeoMatchSetRequest(input, context));
14
+ body = JSON.stringify(_json(input));
15
15
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
16
16
  };
17
17
  export const se_CreateIPSetCommand = async (input, context) => {
18
18
  const headers = sharedHeaders("CreateIPSet");
19
19
  let body;
20
- body = JSON.stringify(se_CreateIPSetRequest(input, context));
20
+ body = JSON.stringify(_json(input));
21
21
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
22
22
  };
23
23
  export const se_CreateRateBasedRuleCommand = async (input, context) => {
24
24
  const headers = sharedHeaders("CreateRateBasedRule");
25
25
  let body;
26
- body = JSON.stringify(se_CreateRateBasedRuleRequest(input, context));
26
+ body = JSON.stringify(_json(input));
27
27
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
28
28
  };
29
29
  export const se_CreateRegexMatchSetCommand = async (input, context) => {
30
30
  const headers = sharedHeaders("CreateRegexMatchSet");
31
31
  let body;
32
- body = JSON.stringify(se_CreateRegexMatchSetRequest(input, context));
32
+ body = JSON.stringify(_json(input));
33
33
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
34
34
  };
35
35
  export const se_CreateRegexPatternSetCommand = async (input, context) => {
36
36
  const headers = sharedHeaders("CreateRegexPatternSet");
37
37
  let body;
38
- body = JSON.stringify(se_CreateRegexPatternSetRequest(input, context));
38
+ body = JSON.stringify(_json(input));
39
39
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
40
40
  };
41
41
  export const se_CreateRuleCommand = async (input, context) => {
42
42
  const headers = sharedHeaders("CreateRule");
43
43
  let body;
44
- body = JSON.stringify(se_CreateRuleRequest(input, context));
44
+ body = JSON.stringify(_json(input));
45
45
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
46
46
  };
47
47
  export const se_CreateRuleGroupCommand = async (input, context) => {
48
48
  const headers = sharedHeaders("CreateRuleGroup");
49
49
  let body;
50
- body = JSON.stringify(se_CreateRuleGroupRequest(input, context));
50
+ body = JSON.stringify(_json(input));
51
51
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
52
52
  };
53
53
  export const se_CreateSizeConstraintSetCommand = async (input, context) => {
54
54
  const headers = sharedHeaders("CreateSizeConstraintSet");
55
55
  let body;
56
- body = JSON.stringify(se_CreateSizeConstraintSetRequest(input, context));
56
+ body = JSON.stringify(_json(input));
57
57
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
58
58
  };
59
59
  export const se_CreateSqlInjectionMatchSetCommand = async (input, context) => {
60
60
  const headers = sharedHeaders("CreateSqlInjectionMatchSet");
61
61
  let body;
62
- body = JSON.stringify(se_CreateSqlInjectionMatchSetRequest(input, context));
62
+ body = JSON.stringify(_json(input));
63
63
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
64
64
  };
65
65
  export const se_CreateWebACLCommand = async (input, context) => {
66
66
  const headers = sharedHeaders("CreateWebACL");
67
67
  let body;
68
- body = JSON.stringify(se_CreateWebACLRequest(input, context));
68
+ body = JSON.stringify(_json(input));
69
69
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
70
70
  };
71
71
  export const se_CreateWebACLMigrationStackCommand = async (input, context) => {
72
72
  const headers = sharedHeaders("CreateWebACLMigrationStack");
73
73
  let body;
74
- body = JSON.stringify(se_CreateWebACLMigrationStackRequest(input, context));
74
+ body = JSON.stringify(_json(input));
75
75
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
76
76
  };
77
77
  export const se_CreateXssMatchSetCommand = async (input, context) => {
78
78
  const headers = sharedHeaders("CreateXssMatchSet");
79
79
  let body;
80
- body = JSON.stringify(se_CreateXssMatchSetRequest(input, context));
80
+ body = JSON.stringify(_json(input));
81
81
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
82
82
  };
83
83
  export const se_DeleteByteMatchSetCommand = async (input, context) => {
84
84
  const headers = sharedHeaders("DeleteByteMatchSet");
85
85
  let body;
86
- body = JSON.stringify(se_DeleteByteMatchSetRequest(input, context));
86
+ body = JSON.stringify(_json(input));
87
87
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
88
88
  };
89
89
  export const se_DeleteGeoMatchSetCommand = async (input, context) => {
90
90
  const headers = sharedHeaders("DeleteGeoMatchSet");
91
91
  let body;
92
- body = JSON.stringify(se_DeleteGeoMatchSetRequest(input, context));
92
+ body = JSON.stringify(_json(input));
93
93
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
94
94
  };
95
95
  export const se_DeleteIPSetCommand = async (input, context) => {
96
96
  const headers = sharedHeaders("DeleteIPSet");
97
97
  let body;
98
- body = JSON.stringify(se_DeleteIPSetRequest(input, context));
98
+ body = JSON.stringify(_json(input));
99
99
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
100
100
  };
101
101
  export const se_DeleteLoggingConfigurationCommand = async (input, context) => {
102
102
  const headers = sharedHeaders("DeleteLoggingConfiguration");
103
103
  let body;
104
- body = JSON.stringify(se_DeleteLoggingConfigurationRequest(input, context));
104
+ body = JSON.stringify(_json(input));
105
105
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
106
106
  };
107
107
  export const se_DeletePermissionPolicyCommand = async (input, context) => {
108
108
  const headers = sharedHeaders("DeletePermissionPolicy");
109
109
  let body;
110
- body = JSON.stringify(se_DeletePermissionPolicyRequest(input, context));
110
+ body = JSON.stringify(_json(input));
111
111
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
112
112
  };
113
113
  export const se_DeleteRateBasedRuleCommand = async (input, context) => {
114
114
  const headers = sharedHeaders("DeleteRateBasedRule");
115
115
  let body;
116
- body = JSON.stringify(se_DeleteRateBasedRuleRequest(input, context));
116
+ body = JSON.stringify(_json(input));
117
117
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
118
118
  };
119
119
  export const se_DeleteRegexMatchSetCommand = async (input, context) => {
120
120
  const headers = sharedHeaders("DeleteRegexMatchSet");
121
121
  let body;
122
- body = JSON.stringify(se_DeleteRegexMatchSetRequest(input, context));
122
+ body = JSON.stringify(_json(input));
123
123
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
124
124
  };
125
125
  export const se_DeleteRegexPatternSetCommand = async (input, context) => {
126
126
  const headers = sharedHeaders("DeleteRegexPatternSet");
127
127
  let body;
128
- body = JSON.stringify(se_DeleteRegexPatternSetRequest(input, context));
128
+ body = JSON.stringify(_json(input));
129
129
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
130
130
  };
131
131
  export const se_DeleteRuleCommand = async (input, context) => {
132
132
  const headers = sharedHeaders("DeleteRule");
133
133
  let body;
134
- body = JSON.stringify(se_DeleteRuleRequest(input, context));
134
+ body = JSON.stringify(_json(input));
135
135
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
136
136
  };
137
137
  export const se_DeleteRuleGroupCommand = async (input, context) => {
138
138
  const headers = sharedHeaders("DeleteRuleGroup");
139
139
  let body;
140
- body = JSON.stringify(se_DeleteRuleGroupRequest(input, context));
140
+ body = JSON.stringify(_json(input));
141
141
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
142
142
  };
143
143
  export const se_DeleteSizeConstraintSetCommand = async (input, context) => {
144
144
  const headers = sharedHeaders("DeleteSizeConstraintSet");
145
145
  let body;
146
- body = JSON.stringify(se_DeleteSizeConstraintSetRequest(input, context));
146
+ body = JSON.stringify(_json(input));
147
147
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
148
148
  };
149
149
  export const se_DeleteSqlInjectionMatchSetCommand = async (input, context) => {
150
150
  const headers = sharedHeaders("DeleteSqlInjectionMatchSet");
151
151
  let body;
152
- body = JSON.stringify(se_DeleteSqlInjectionMatchSetRequest(input, context));
152
+ body = JSON.stringify(_json(input));
153
153
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
154
154
  };
155
155
  export const se_DeleteWebACLCommand = async (input, context) => {
156
156
  const headers = sharedHeaders("DeleteWebACL");
157
157
  let body;
158
- body = JSON.stringify(se_DeleteWebACLRequest(input, context));
158
+ body = JSON.stringify(_json(input));
159
159
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
160
160
  };
161
161
  export const se_DeleteXssMatchSetCommand = async (input, context) => {
162
162
  const headers = sharedHeaders("DeleteXssMatchSet");
163
163
  let body;
164
- body = JSON.stringify(se_DeleteXssMatchSetRequest(input, context));
164
+ body = JSON.stringify(_json(input));
165
165
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
166
166
  };
167
167
  export const se_GetByteMatchSetCommand = async (input, context) => {
168
168
  const headers = sharedHeaders("GetByteMatchSet");
169
169
  let body;
170
- body = JSON.stringify(se_GetByteMatchSetRequest(input, context));
170
+ body = JSON.stringify(_json(input));
171
171
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
172
172
  };
173
173
  export const se_GetChangeTokenCommand = async (input, context) => {
174
174
  const headers = sharedHeaders("GetChangeToken");
175
175
  let body;
176
- body = JSON.stringify(se_GetChangeTokenRequest(input, context));
176
+ body = JSON.stringify(_json(input));
177
177
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
178
178
  };
179
179
  export const se_GetChangeTokenStatusCommand = async (input, context) => {
180
180
  const headers = sharedHeaders("GetChangeTokenStatus");
181
181
  let body;
182
- body = JSON.stringify(se_GetChangeTokenStatusRequest(input, context));
182
+ body = JSON.stringify(_json(input));
183
183
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
184
184
  };
185
185
  export const se_GetGeoMatchSetCommand = async (input, context) => {
186
186
  const headers = sharedHeaders("GetGeoMatchSet");
187
187
  let body;
188
- body = JSON.stringify(se_GetGeoMatchSetRequest(input, context));
188
+ body = JSON.stringify(_json(input));
189
189
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
190
190
  };
191
191
  export const se_GetIPSetCommand = async (input, context) => {
192
192
  const headers = sharedHeaders("GetIPSet");
193
193
  let body;
194
- body = JSON.stringify(se_GetIPSetRequest(input, context));
194
+ body = JSON.stringify(_json(input));
195
195
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
196
196
  };
197
197
  export const se_GetLoggingConfigurationCommand = async (input, context) => {
198
198
  const headers = sharedHeaders("GetLoggingConfiguration");
199
199
  let body;
200
- body = JSON.stringify(se_GetLoggingConfigurationRequest(input, context));
200
+ body = JSON.stringify(_json(input));
201
201
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
202
202
  };
203
203
  export const se_GetPermissionPolicyCommand = async (input, context) => {
204
204
  const headers = sharedHeaders("GetPermissionPolicy");
205
205
  let body;
206
- body = JSON.stringify(se_GetPermissionPolicyRequest(input, context));
206
+ body = JSON.stringify(_json(input));
207
207
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
208
208
  };
209
209
  export const se_GetRateBasedRuleCommand = async (input, context) => {
210
210
  const headers = sharedHeaders("GetRateBasedRule");
211
211
  let body;
212
- body = JSON.stringify(se_GetRateBasedRuleRequest(input, context));
212
+ body = JSON.stringify(_json(input));
213
213
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
214
214
  };
215
215
  export const se_GetRateBasedRuleManagedKeysCommand = async (input, context) => {
216
216
  const headers = sharedHeaders("GetRateBasedRuleManagedKeys");
217
217
  let body;
218
- body = JSON.stringify(se_GetRateBasedRuleManagedKeysRequest(input, context));
218
+ body = JSON.stringify(_json(input));
219
219
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
220
220
  };
221
221
  export const se_GetRegexMatchSetCommand = async (input, context) => {
222
222
  const headers = sharedHeaders("GetRegexMatchSet");
223
223
  let body;
224
- body = JSON.stringify(se_GetRegexMatchSetRequest(input, context));
224
+ body = JSON.stringify(_json(input));
225
225
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
226
226
  };
227
227
  export const se_GetRegexPatternSetCommand = async (input, context) => {
228
228
  const headers = sharedHeaders("GetRegexPatternSet");
229
229
  let body;
230
- body = JSON.stringify(se_GetRegexPatternSetRequest(input, context));
230
+ body = JSON.stringify(_json(input));
231
231
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
232
232
  };
233
233
  export const se_GetRuleCommand = async (input, context) => {
234
234
  const headers = sharedHeaders("GetRule");
235
235
  let body;
236
- body = JSON.stringify(se_GetRuleRequest(input, context));
236
+ body = JSON.stringify(_json(input));
237
237
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
238
238
  };
239
239
  export const se_GetRuleGroupCommand = async (input, context) => {
240
240
  const headers = sharedHeaders("GetRuleGroup");
241
241
  let body;
242
- body = JSON.stringify(se_GetRuleGroupRequest(input, context));
242
+ body = JSON.stringify(_json(input));
243
243
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
244
244
  };
245
245
  export const se_GetSampledRequestsCommand = async (input, context) => {
@@ -251,145 +251,145 @@ export const se_GetSampledRequestsCommand = async (input, context) => {
251
251
  export const se_GetSizeConstraintSetCommand = async (input, context) => {
252
252
  const headers = sharedHeaders("GetSizeConstraintSet");
253
253
  let body;
254
- body = JSON.stringify(se_GetSizeConstraintSetRequest(input, context));
254
+ body = JSON.stringify(_json(input));
255
255
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
256
256
  };
257
257
  export const se_GetSqlInjectionMatchSetCommand = async (input, context) => {
258
258
  const headers = sharedHeaders("GetSqlInjectionMatchSet");
259
259
  let body;
260
- body = JSON.stringify(se_GetSqlInjectionMatchSetRequest(input, context));
260
+ body = JSON.stringify(_json(input));
261
261
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
262
262
  };
263
263
  export const se_GetWebACLCommand = async (input, context) => {
264
264
  const headers = sharedHeaders("GetWebACL");
265
265
  let body;
266
- body = JSON.stringify(se_GetWebACLRequest(input, context));
266
+ body = JSON.stringify(_json(input));
267
267
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
268
268
  };
269
269
  export const se_GetXssMatchSetCommand = async (input, context) => {
270
270
  const headers = sharedHeaders("GetXssMatchSet");
271
271
  let body;
272
- body = JSON.stringify(se_GetXssMatchSetRequest(input, context));
272
+ body = JSON.stringify(_json(input));
273
273
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
274
274
  };
275
275
  export const se_ListActivatedRulesInRuleGroupCommand = async (input, context) => {
276
276
  const headers = sharedHeaders("ListActivatedRulesInRuleGroup");
277
277
  let body;
278
- body = JSON.stringify(se_ListActivatedRulesInRuleGroupRequest(input, context));
278
+ body = JSON.stringify(_json(input));
279
279
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
280
280
  };
281
281
  export const se_ListByteMatchSetsCommand = async (input, context) => {
282
282
  const headers = sharedHeaders("ListByteMatchSets");
283
283
  let body;
284
- body = JSON.stringify(se_ListByteMatchSetsRequest(input, context));
284
+ body = JSON.stringify(_json(input));
285
285
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
286
286
  };
287
287
  export const se_ListGeoMatchSetsCommand = async (input, context) => {
288
288
  const headers = sharedHeaders("ListGeoMatchSets");
289
289
  let body;
290
- body = JSON.stringify(se_ListGeoMatchSetsRequest(input, context));
290
+ body = JSON.stringify(_json(input));
291
291
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
292
292
  };
293
293
  export const se_ListIPSetsCommand = async (input, context) => {
294
294
  const headers = sharedHeaders("ListIPSets");
295
295
  let body;
296
- body = JSON.stringify(se_ListIPSetsRequest(input, context));
296
+ body = JSON.stringify(_json(input));
297
297
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
298
298
  };
299
299
  export const se_ListLoggingConfigurationsCommand = async (input, context) => {
300
300
  const headers = sharedHeaders("ListLoggingConfigurations");
301
301
  let body;
302
- body = JSON.stringify(se_ListLoggingConfigurationsRequest(input, context));
302
+ body = JSON.stringify(_json(input));
303
303
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
304
304
  };
305
305
  export const se_ListRateBasedRulesCommand = async (input, context) => {
306
306
  const headers = sharedHeaders("ListRateBasedRules");
307
307
  let body;
308
- body = JSON.stringify(se_ListRateBasedRulesRequest(input, context));
308
+ body = JSON.stringify(_json(input));
309
309
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
310
310
  };
311
311
  export const se_ListRegexMatchSetsCommand = async (input, context) => {
312
312
  const headers = sharedHeaders("ListRegexMatchSets");
313
313
  let body;
314
- body = JSON.stringify(se_ListRegexMatchSetsRequest(input, context));
314
+ body = JSON.stringify(_json(input));
315
315
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
316
316
  };
317
317
  export const se_ListRegexPatternSetsCommand = async (input, context) => {
318
318
  const headers = sharedHeaders("ListRegexPatternSets");
319
319
  let body;
320
- body = JSON.stringify(se_ListRegexPatternSetsRequest(input, context));
320
+ body = JSON.stringify(_json(input));
321
321
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
322
322
  };
323
323
  export const se_ListRuleGroupsCommand = async (input, context) => {
324
324
  const headers = sharedHeaders("ListRuleGroups");
325
325
  let body;
326
- body = JSON.stringify(se_ListRuleGroupsRequest(input, context));
326
+ body = JSON.stringify(_json(input));
327
327
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
328
328
  };
329
329
  export const se_ListRulesCommand = async (input, context) => {
330
330
  const headers = sharedHeaders("ListRules");
331
331
  let body;
332
- body = JSON.stringify(se_ListRulesRequest(input, context));
332
+ body = JSON.stringify(_json(input));
333
333
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
334
334
  };
335
335
  export const se_ListSizeConstraintSetsCommand = async (input, context) => {
336
336
  const headers = sharedHeaders("ListSizeConstraintSets");
337
337
  let body;
338
- body = JSON.stringify(se_ListSizeConstraintSetsRequest(input, context));
338
+ body = JSON.stringify(_json(input));
339
339
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
340
340
  };
341
341
  export const se_ListSqlInjectionMatchSetsCommand = async (input, context) => {
342
342
  const headers = sharedHeaders("ListSqlInjectionMatchSets");
343
343
  let body;
344
- body = JSON.stringify(se_ListSqlInjectionMatchSetsRequest(input, context));
344
+ body = JSON.stringify(_json(input));
345
345
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
346
346
  };
347
347
  export const se_ListSubscribedRuleGroupsCommand = async (input, context) => {
348
348
  const headers = sharedHeaders("ListSubscribedRuleGroups");
349
349
  let body;
350
- body = JSON.stringify(se_ListSubscribedRuleGroupsRequest(input, context));
350
+ body = JSON.stringify(_json(input));
351
351
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
352
352
  };
353
353
  export const se_ListTagsForResourceCommand = async (input, context) => {
354
354
  const headers = sharedHeaders("ListTagsForResource");
355
355
  let body;
356
- body = JSON.stringify(se_ListTagsForResourceRequest(input, context));
356
+ body = JSON.stringify(_json(input));
357
357
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
358
358
  };
359
359
  export const se_ListWebACLsCommand = async (input, context) => {
360
360
  const headers = sharedHeaders("ListWebACLs");
361
361
  let body;
362
- body = JSON.stringify(se_ListWebACLsRequest(input, context));
362
+ body = JSON.stringify(_json(input));
363
363
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
364
364
  };
365
365
  export const se_ListXssMatchSetsCommand = async (input, context) => {
366
366
  const headers = sharedHeaders("ListXssMatchSets");
367
367
  let body;
368
- body = JSON.stringify(se_ListXssMatchSetsRequest(input, context));
368
+ body = JSON.stringify(_json(input));
369
369
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
370
370
  };
371
371
  export const se_PutLoggingConfigurationCommand = async (input, context) => {
372
372
  const headers = sharedHeaders("PutLoggingConfiguration");
373
373
  let body;
374
- body = JSON.stringify(se_PutLoggingConfigurationRequest(input, context));
374
+ body = JSON.stringify(_json(input));
375
375
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
376
376
  };
377
377
  export const se_PutPermissionPolicyCommand = async (input, context) => {
378
378
  const headers = sharedHeaders("PutPermissionPolicy");
379
379
  let body;
380
- body = JSON.stringify(se_PutPermissionPolicyRequest(input, context));
380
+ body = JSON.stringify(_json(input));
381
381
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
382
382
  };
383
383
  export const se_TagResourceCommand = async (input, context) => {
384
384
  const headers = sharedHeaders("TagResource");
385
385
  let body;
386
- body = JSON.stringify(se_TagResourceRequest(input, context));
386
+ body = JSON.stringify(_json(input));
387
387
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
388
388
  };
389
389
  export const se_UntagResourceCommand = async (input, context) => {
390
390
  const headers = sharedHeaders("UntagResource");
391
391
  let body;
392
- body = JSON.stringify(se_UntagResourceRequest(input, context));
392
+ body = JSON.stringify(_json(input));
393
393
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
394
394
  };
395
395
  export const se_UpdateByteMatchSetCommand = async (input, context) => {
@@ -401,67 +401,67 @@ export const se_UpdateByteMatchSetCommand = async (input, context) => {
401
401
  export const se_UpdateGeoMatchSetCommand = async (input, context) => {
402
402
  const headers = sharedHeaders("UpdateGeoMatchSet");
403
403
  let body;
404
- body = JSON.stringify(se_UpdateGeoMatchSetRequest(input, context));
404
+ body = JSON.stringify(_json(input));
405
405
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
406
406
  };
407
407
  export const se_UpdateIPSetCommand = async (input, context) => {
408
408
  const headers = sharedHeaders("UpdateIPSet");
409
409
  let body;
410
- body = JSON.stringify(se_UpdateIPSetRequest(input, context));
410
+ body = JSON.stringify(_json(input));
411
411
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
412
412
  };
413
413
  export const se_UpdateRateBasedRuleCommand = async (input, context) => {
414
414
  const headers = sharedHeaders("UpdateRateBasedRule");
415
415
  let body;
416
- body = JSON.stringify(se_UpdateRateBasedRuleRequest(input, context));
416
+ body = JSON.stringify(_json(input));
417
417
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
418
418
  };
419
419
  export const se_UpdateRegexMatchSetCommand = async (input, context) => {
420
420
  const headers = sharedHeaders("UpdateRegexMatchSet");
421
421
  let body;
422
- body = JSON.stringify(se_UpdateRegexMatchSetRequest(input, context));
422
+ body = JSON.stringify(_json(input));
423
423
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
424
424
  };
425
425
  export const se_UpdateRegexPatternSetCommand = async (input, context) => {
426
426
  const headers = sharedHeaders("UpdateRegexPatternSet");
427
427
  let body;
428
- body = JSON.stringify(se_UpdateRegexPatternSetRequest(input, context));
428
+ body = JSON.stringify(_json(input));
429
429
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
430
430
  };
431
431
  export const se_UpdateRuleCommand = async (input, context) => {
432
432
  const headers = sharedHeaders("UpdateRule");
433
433
  let body;
434
- body = JSON.stringify(se_UpdateRuleRequest(input, context));
434
+ body = JSON.stringify(_json(input));
435
435
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
436
436
  };
437
437
  export const se_UpdateRuleGroupCommand = async (input, context) => {
438
438
  const headers = sharedHeaders("UpdateRuleGroup");
439
439
  let body;
440
- body = JSON.stringify(se_UpdateRuleGroupRequest(input, context));
440
+ body = JSON.stringify(_json(input));
441
441
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
442
442
  };
443
443
  export const se_UpdateSizeConstraintSetCommand = async (input, context) => {
444
444
  const headers = sharedHeaders("UpdateSizeConstraintSet");
445
445
  let body;
446
- body = JSON.stringify(se_UpdateSizeConstraintSetRequest(input, context));
446
+ body = JSON.stringify(_json(input));
447
447
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
448
448
  };
449
449
  export const se_UpdateSqlInjectionMatchSetCommand = async (input, context) => {
450
450
  const headers = sharedHeaders("UpdateSqlInjectionMatchSet");
451
451
  let body;
452
- body = JSON.stringify(se_UpdateSqlInjectionMatchSetRequest(input, context));
452
+ body = JSON.stringify(_json(input));
453
453
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
454
454
  };
455
455
  export const se_UpdateWebACLCommand = async (input, context) => {
456
456
  const headers = sharedHeaders("UpdateWebACL");
457
457
  let body;
458
- body = JSON.stringify(se_UpdateWebACLRequest(input, context));
458
+ body = JSON.stringify(_json(input));
459
459
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
460
460
  };
461
461
  export const se_UpdateXssMatchSetCommand = async (input, context) => {
462
462
  const headers = sharedHeaders("UpdateXssMatchSet");
463
463
  let body;
464
- body = JSON.stringify(se_UpdateXssMatchSetRequest(input, context));
464
+ body = JSON.stringify(_json(input));
465
465
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
466
466
  };
467
467
  export const de_CreateByteMatchSetCommand = async (output, context) => {
@@ -475,7 +475,7 @@ export const de_CreateByteMatchSetCommand = async (output, context) => {
475
475
  $metadata: deserializeMetadata(output),
476
476
  ...contents,
477
477
  };
478
- return Promise.resolve(response);
478
+ return response;
479
479
  };
480
480
  const de_CreateByteMatchSetCommandError = async (output, context) => {
481
481
  const parsedOutput = {
@@ -504,10 +504,9 @@ const de_CreateByteMatchSetCommandError = async (output, context) => {
504
504
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
505
505
  default:
506
506
  const parsedBody = parsedOutput.body;
507
- throwDefaultError({
507
+ return throwDefaultError({
508
508
  output,
509
509
  parsedBody,
510
- exceptionCtor: __BaseException,
511
510
  errorCode,
512
511
  });
513
512
  }
@@ -518,12 +517,12 @@ export const de_CreateGeoMatchSetCommand = async (output, context) => {
518
517
  }
519
518
  const data = await parseBody(output.body, context);
520
519
  let contents = {};
521
- contents = de_CreateGeoMatchSetResponse(data, context);
520
+ contents = _json(data);
522
521
  const response = {
523
522
  $metadata: deserializeMetadata(output),
524
523
  ...contents,
525
524
  };
526
- return Promise.resolve(response);
525
+ return response;
527
526
  };
528
527
  const de_CreateGeoMatchSetCommandError = async (output, context) => {
529
528
  const parsedOutput = {
@@ -552,10 +551,9 @@ const de_CreateGeoMatchSetCommandError = async (output, context) => {
552
551
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
553
552
  default:
554
553
  const parsedBody = parsedOutput.body;
555
- throwDefaultError({
554
+ return throwDefaultError({
556
555
  output,
557
556
  parsedBody,
558
- exceptionCtor: __BaseException,
559
557
  errorCode,
560
558
  });
561
559
  }
@@ -566,12 +564,12 @@ export const de_CreateIPSetCommand = async (output, context) => {
566
564
  }
567
565
  const data = await parseBody(output.body, context);
568
566
  let contents = {};
569
- contents = de_CreateIPSetResponse(data, context);
567
+ contents = _json(data);
570
568
  const response = {
571
569
  $metadata: deserializeMetadata(output),
572
570
  ...contents,
573
571
  };
574
- return Promise.resolve(response);
572
+ return response;
575
573
  };
576
574
  const de_CreateIPSetCommandError = async (output, context) => {
577
575
  const parsedOutput = {
@@ -600,10 +598,9 @@ const de_CreateIPSetCommandError = async (output, context) => {
600
598
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
601
599
  default:
602
600
  const parsedBody = parsedOutput.body;
603
- throwDefaultError({
601
+ return throwDefaultError({
604
602
  output,
605
603
  parsedBody,
606
- exceptionCtor: __BaseException,
607
604
  errorCode,
608
605
  });
609
606
  }
@@ -614,12 +611,12 @@ export const de_CreateRateBasedRuleCommand = async (output, context) => {
614
611
  }
615
612
  const data = await parseBody(output.body, context);
616
613
  let contents = {};
617
- contents = de_CreateRateBasedRuleResponse(data, context);
614
+ contents = _json(data);
618
615
  const response = {
619
616
  $metadata: deserializeMetadata(output),
620
617
  ...contents,
621
618
  };
622
- return Promise.resolve(response);
619
+ return response;
623
620
  };
624
621
  const de_CreateRateBasedRuleCommandError = async (output, context) => {
625
622
  const parsedOutput = {
@@ -654,10 +651,9 @@ const de_CreateRateBasedRuleCommandError = async (output, context) => {
654
651
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
655
652
  default:
656
653
  const parsedBody = parsedOutput.body;
657
- throwDefaultError({
654
+ return throwDefaultError({
658
655
  output,
659
656
  parsedBody,
660
- exceptionCtor: __BaseException,
661
657
  errorCode,
662
658
  });
663
659
  }
@@ -668,12 +664,12 @@ export const de_CreateRegexMatchSetCommand = async (output, context) => {
668
664
  }
669
665
  const data = await parseBody(output.body, context);
670
666
  let contents = {};
671
- contents = de_CreateRegexMatchSetResponse(data, context);
667
+ contents = _json(data);
672
668
  const response = {
673
669
  $metadata: deserializeMetadata(output),
674
670
  ...contents,
675
671
  };
676
- return Promise.resolve(response);
672
+ return response;
677
673
  };
678
674
  const de_CreateRegexMatchSetCommandError = async (output, context) => {
679
675
  const parsedOutput = {
@@ -696,10 +692,9 @@ const de_CreateRegexMatchSetCommandError = async (output, context) => {
696
692
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
697
693
  default:
698
694
  const parsedBody = parsedOutput.body;
699
- throwDefaultError({
695
+ return throwDefaultError({
700
696
  output,
701
697
  parsedBody,
702
- exceptionCtor: __BaseException,
703
698
  errorCode,
704
699
  });
705
700
  }
@@ -710,12 +705,12 @@ export const de_CreateRegexPatternSetCommand = async (output, context) => {
710
705
  }
711
706
  const data = await parseBody(output.body, context);
712
707
  let contents = {};
713
- contents = de_CreateRegexPatternSetResponse(data, context);
708
+ contents = _json(data);
714
709
  const response = {
715
710
  $metadata: deserializeMetadata(output),
716
711
  ...contents,
717
712
  };
718
- return Promise.resolve(response);
713
+ return response;
719
714
  };
720
715
  const de_CreateRegexPatternSetCommandError = async (output, context) => {
721
716
  const parsedOutput = {
@@ -738,10 +733,9 @@ const de_CreateRegexPatternSetCommandError = async (output, context) => {
738
733
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
739
734
  default:
740
735
  const parsedBody = parsedOutput.body;
741
- throwDefaultError({
736
+ return throwDefaultError({
742
737
  output,
743
738
  parsedBody,
744
- exceptionCtor: __BaseException,
745
739
  errorCode,
746
740
  });
747
741
  }
@@ -752,12 +746,12 @@ export const de_CreateRuleCommand = async (output, context) => {
752
746
  }
753
747
  const data = await parseBody(output.body, context);
754
748
  let contents = {};
755
- contents = de_CreateRuleResponse(data, context);
749
+ contents = _json(data);
756
750
  const response = {
757
751
  $metadata: deserializeMetadata(output),
758
752
  ...contents,
759
753
  };
760
- return Promise.resolve(response);
754
+ return response;
761
755
  };
762
756
  const de_CreateRuleCommandError = async (output, context) => {
763
757
  const parsedOutput = {
@@ -792,10 +786,9 @@ const de_CreateRuleCommandError = async (output, context) => {
792
786
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
793
787
  default:
794
788
  const parsedBody = parsedOutput.body;
795
- throwDefaultError({
789
+ return throwDefaultError({
796
790
  output,
797
791
  parsedBody,
798
- exceptionCtor: __BaseException,
799
792
  errorCode,
800
793
  });
801
794
  }
@@ -806,12 +799,12 @@ export const de_CreateRuleGroupCommand = async (output, context) => {
806
799
  }
807
800
  const data = await parseBody(output.body, context);
808
801
  let contents = {};
809
- contents = de_CreateRuleGroupResponse(data, context);
802
+ contents = _json(data);
810
803
  const response = {
811
804
  $metadata: deserializeMetadata(output),
812
805
  ...contents,
813
806
  };
814
- return Promise.resolve(response);
807
+ return response;
815
808
  };
816
809
  const de_CreateRuleGroupCommandError = async (output, context) => {
817
810
  const parsedOutput = {
@@ -843,10 +836,9 @@ const de_CreateRuleGroupCommandError = async (output, context) => {
843
836
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
844
837
  default:
845
838
  const parsedBody = parsedOutput.body;
846
- throwDefaultError({
839
+ return throwDefaultError({
847
840
  output,
848
841
  parsedBody,
849
- exceptionCtor: __BaseException,
850
842
  errorCode,
851
843
  });
852
844
  }
@@ -857,12 +849,12 @@ export const de_CreateSizeConstraintSetCommand = async (output, context) => {
857
849
  }
858
850
  const data = await parseBody(output.body, context);
859
851
  let contents = {};
860
- contents = de_CreateSizeConstraintSetResponse(data, context);
852
+ contents = _json(data);
861
853
  const response = {
862
854
  $metadata: deserializeMetadata(output),
863
855
  ...contents,
864
856
  };
865
- return Promise.resolve(response);
857
+ return response;
866
858
  };
867
859
  const de_CreateSizeConstraintSetCommandError = async (output, context) => {
868
860
  const parsedOutput = {
@@ -891,10 +883,9 @@ const de_CreateSizeConstraintSetCommandError = async (output, context) => {
891
883
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
892
884
  default:
893
885
  const parsedBody = parsedOutput.body;
894
- throwDefaultError({
886
+ return throwDefaultError({
895
887
  output,
896
888
  parsedBody,
897
- exceptionCtor: __BaseException,
898
889
  errorCode,
899
890
  });
900
891
  }
@@ -905,12 +896,12 @@ export const de_CreateSqlInjectionMatchSetCommand = async (output, context) => {
905
896
  }
906
897
  const data = await parseBody(output.body, context);
907
898
  let contents = {};
908
- contents = de_CreateSqlInjectionMatchSetResponse(data, context);
899
+ contents = _json(data);
909
900
  const response = {
910
901
  $metadata: deserializeMetadata(output),
911
902
  ...contents,
912
903
  };
913
- return Promise.resolve(response);
904
+ return response;
914
905
  };
915
906
  const de_CreateSqlInjectionMatchSetCommandError = async (output, context) => {
916
907
  const parsedOutput = {
@@ -939,10 +930,9 @@ const de_CreateSqlInjectionMatchSetCommandError = async (output, context) => {
939
930
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
940
931
  default:
941
932
  const parsedBody = parsedOutput.body;
942
- throwDefaultError({
933
+ return throwDefaultError({
943
934
  output,
944
935
  parsedBody,
945
- exceptionCtor: __BaseException,
946
936
  errorCode,
947
937
  });
948
938
  }
@@ -953,12 +943,12 @@ export const de_CreateWebACLCommand = async (output, context) => {
953
943
  }
954
944
  const data = await parseBody(output.body, context);
955
945
  let contents = {};
956
- contents = de_CreateWebACLResponse(data, context);
946
+ contents = _json(data);
957
947
  const response = {
958
948
  $metadata: deserializeMetadata(output),
959
949
  ...contents,
960
950
  };
961
- return Promise.resolve(response);
951
+ return response;
962
952
  };
963
953
  const de_CreateWebACLCommandError = async (output, context) => {
964
954
  const parsedOutput = {
@@ -996,10 +986,9 @@ const de_CreateWebACLCommandError = async (output, context) => {
996
986
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
997
987
  default:
998
988
  const parsedBody = parsedOutput.body;
999
- throwDefaultError({
989
+ return throwDefaultError({
1000
990
  output,
1001
991
  parsedBody,
1002
- exceptionCtor: __BaseException,
1003
992
  errorCode,
1004
993
  });
1005
994
  }
@@ -1010,12 +999,12 @@ export const de_CreateWebACLMigrationStackCommand = async (output, context) => {
1010
999
  }
1011
1000
  const data = await parseBody(output.body, context);
1012
1001
  let contents = {};
1013
- contents = de_CreateWebACLMigrationStackResponse(data, context);
1002
+ contents = _json(data);
1014
1003
  const response = {
1015
1004
  $metadata: deserializeMetadata(output),
1016
1005
  ...contents,
1017
1006
  };
1018
- return Promise.resolve(response);
1007
+ return response;
1019
1008
  };
1020
1009
  const de_CreateWebACLMigrationStackCommandError = async (output, context) => {
1021
1010
  const parsedOutput = {
@@ -1041,10 +1030,9 @@ const de_CreateWebACLMigrationStackCommandError = async (output, context) => {
1041
1030
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
1042
1031
  default:
1043
1032
  const parsedBody = parsedOutput.body;
1044
- throwDefaultError({
1033
+ return throwDefaultError({
1045
1034
  output,
1046
1035
  parsedBody,
1047
- exceptionCtor: __BaseException,
1048
1036
  errorCode,
1049
1037
  });
1050
1038
  }
@@ -1055,12 +1043,12 @@ export const de_CreateXssMatchSetCommand = async (output, context) => {
1055
1043
  }
1056
1044
  const data = await parseBody(output.body, context);
1057
1045
  let contents = {};
1058
- contents = de_CreateXssMatchSetResponse(data, context);
1046
+ contents = _json(data);
1059
1047
  const response = {
1060
1048
  $metadata: deserializeMetadata(output),
1061
1049
  ...contents,
1062
1050
  };
1063
- return Promise.resolve(response);
1051
+ return response;
1064
1052
  };
1065
1053
  const de_CreateXssMatchSetCommandError = async (output, context) => {
1066
1054
  const parsedOutput = {
@@ -1089,10 +1077,9 @@ const de_CreateXssMatchSetCommandError = async (output, context) => {
1089
1077
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1090
1078
  default:
1091
1079
  const parsedBody = parsedOutput.body;
1092
- throwDefaultError({
1080
+ return throwDefaultError({
1093
1081
  output,
1094
1082
  parsedBody,
1095
- exceptionCtor: __BaseException,
1096
1083
  errorCode,
1097
1084
  });
1098
1085
  }
@@ -1103,12 +1090,12 @@ export const de_DeleteByteMatchSetCommand = async (output, context) => {
1103
1090
  }
1104
1091
  const data = await parseBody(output.body, context);
1105
1092
  let contents = {};
1106
- contents = de_DeleteByteMatchSetResponse(data, context);
1093
+ contents = _json(data);
1107
1094
  const response = {
1108
1095
  $metadata: deserializeMetadata(output),
1109
1096
  ...contents,
1110
1097
  };
1111
- return Promise.resolve(response);
1098
+ return response;
1112
1099
  };
1113
1100
  const de_DeleteByteMatchSetCommandError = async (output, context) => {
1114
1101
  const parsedOutput = {
@@ -1137,10 +1124,9 @@ const de_DeleteByteMatchSetCommandError = async (output, context) => {
1137
1124
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1138
1125
  default:
1139
1126
  const parsedBody = parsedOutput.body;
1140
- throwDefaultError({
1127
+ return throwDefaultError({
1141
1128
  output,
1142
1129
  parsedBody,
1143
- exceptionCtor: __BaseException,
1144
1130
  errorCode,
1145
1131
  });
1146
1132
  }
@@ -1151,12 +1137,12 @@ export const de_DeleteGeoMatchSetCommand = async (output, context) => {
1151
1137
  }
1152
1138
  const data = await parseBody(output.body, context);
1153
1139
  let contents = {};
1154
- contents = de_DeleteGeoMatchSetResponse(data, context);
1140
+ contents = _json(data);
1155
1141
  const response = {
1156
1142
  $metadata: deserializeMetadata(output),
1157
1143
  ...contents,
1158
1144
  };
1159
- return Promise.resolve(response);
1145
+ return response;
1160
1146
  };
1161
1147
  const de_DeleteGeoMatchSetCommandError = async (output, context) => {
1162
1148
  const parsedOutput = {
@@ -1185,10 +1171,9 @@ const de_DeleteGeoMatchSetCommandError = async (output, context) => {
1185
1171
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1186
1172
  default:
1187
1173
  const parsedBody = parsedOutput.body;
1188
- throwDefaultError({
1174
+ return throwDefaultError({
1189
1175
  output,
1190
1176
  parsedBody,
1191
- exceptionCtor: __BaseException,
1192
1177
  errorCode,
1193
1178
  });
1194
1179
  }
@@ -1199,12 +1184,12 @@ export const de_DeleteIPSetCommand = async (output, context) => {
1199
1184
  }
1200
1185
  const data = await parseBody(output.body, context);
1201
1186
  let contents = {};
1202
- contents = de_DeleteIPSetResponse(data, context);
1187
+ contents = _json(data);
1203
1188
  const response = {
1204
1189
  $metadata: deserializeMetadata(output),
1205
1190
  ...contents,
1206
1191
  };
1207
- return Promise.resolve(response);
1192
+ return response;
1208
1193
  };
1209
1194
  const de_DeleteIPSetCommandError = async (output, context) => {
1210
1195
  const parsedOutput = {
@@ -1233,10 +1218,9 @@ const de_DeleteIPSetCommandError = async (output, context) => {
1233
1218
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1234
1219
  default:
1235
1220
  const parsedBody = parsedOutput.body;
1236
- throwDefaultError({
1221
+ return throwDefaultError({
1237
1222
  output,
1238
1223
  parsedBody,
1239
- exceptionCtor: __BaseException,
1240
1224
  errorCode,
1241
1225
  });
1242
1226
  }
@@ -1247,12 +1231,12 @@ export const de_DeleteLoggingConfigurationCommand = async (output, context) => {
1247
1231
  }
1248
1232
  const data = await parseBody(output.body, context);
1249
1233
  let contents = {};
1250
- contents = de_DeleteLoggingConfigurationResponse(data, context);
1234
+ contents = _json(data);
1251
1235
  const response = {
1252
1236
  $metadata: deserializeMetadata(output),
1253
1237
  ...contents,
1254
1238
  };
1255
- return Promise.resolve(response);
1239
+ return response;
1256
1240
  };
1257
1241
  const de_DeleteLoggingConfigurationCommandError = async (output, context) => {
1258
1242
  const parsedOutput = {
@@ -1272,10 +1256,9 @@ const de_DeleteLoggingConfigurationCommandError = async (output, context) => {
1272
1256
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1273
1257
  default:
1274
1258
  const parsedBody = parsedOutput.body;
1275
- throwDefaultError({
1259
+ return throwDefaultError({
1276
1260
  output,
1277
1261
  parsedBody,
1278
- exceptionCtor: __BaseException,
1279
1262
  errorCode,
1280
1263
  });
1281
1264
  }
@@ -1286,12 +1269,12 @@ export const de_DeletePermissionPolicyCommand = async (output, context) => {
1286
1269
  }
1287
1270
  const data = await parseBody(output.body, context);
1288
1271
  let contents = {};
1289
- contents = de_DeletePermissionPolicyResponse(data, context);
1272
+ contents = _json(data);
1290
1273
  const response = {
1291
1274
  $metadata: deserializeMetadata(output),
1292
1275
  ...contents,
1293
1276
  };
1294
- return Promise.resolve(response);
1277
+ return response;
1295
1278
  };
1296
1279
  const de_DeletePermissionPolicyCommandError = async (output, context) => {
1297
1280
  const parsedOutput = {
@@ -1311,10 +1294,9 @@ const de_DeletePermissionPolicyCommandError = async (output, context) => {
1311
1294
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1312
1295
  default:
1313
1296
  const parsedBody = parsedOutput.body;
1314
- throwDefaultError({
1297
+ return throwDefaultError({
1315
1298
  output,
1316
1299
  parsedBody,
1317
- exceptionCtor: __BaseException,
1318
1300
  errorCode,
1319
1301
  });
1320
1302
  }
@@ -1325,12 +1307,12 @@ export const de_DeleteRateBasedRuleCommand = async (output, context) => {
1325
1307
  }
1326
1308
  const data = await parseBody(output.body, context);
1327
1309
  let contents = {};
1328
- contents = de_DeleteRateBasedRuleResponse(data, context);
1310
+ contents = _json(data);
1329
1311
  const response = {
1330
1312
  $metadata: deserializeMetadata(output),
1331
1313
  ...contents,
1332
1314
  };
1333
- return Promise.resolve(response);
1315
+ return response;
1334
1316
  };
1335
1317
  const de_DeleteRateBasedRuleCommandError = async (output, context) => {
1336
1318
  const parsedOutput = {
@@ -1365,10 +1347,9 @@ const de_DeleteRateBasedRuleCommandError = async (output, context) => {
1365
1347
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
1366
1348
  default:
1367
1349
  const parsedBody = parsedOutput.body;
1368
- throwDefaultError({
1350
+ return throwDefaultError({
1369
1351
  output,
1370
1352
  parsedBody,
1371
- exceptionCtor: __BaseException,
1372
1353
  errorCode,
1373
1354
  });
1374
1355
  }
@@ -1379,12 +1360,12 @@ export const de_DeleteRegexMatchSetCommand = async (output, context) => {
1379
1360
  }
1380
1361
  const data = await parseBody(output.body, context);
1381
1362
  let contents = {};
1382
- contents = de_DeleteRegexMatchSetResponse(data, context);
1363
+ contents = _json(data);
1383
1364
  const response = {
1384
1365
  $metadata: deserializeMetadata(output),
1385
1366
  ...contents,
1386
1367
  };
1387
- return Promise.resolve(response);
1368
+ return response;
1388
1369
  };
1389
1370
  const de_DeleteRegexMatchSetCommandError = async (output, context) => {
1390
1371
  const parsedOutput = {
@@ -1413,10 +1394,9 @@ const de_DeleteRegexMatchSetCommandError = async (output, context) => {
1413
1394
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1414
1395
  default:
1415
1396
  const parsedBody = parsedOutput.body;
1416
- throwDefaultError({
1397
+ return throwDefaultError({
1417
1398
  output,
1418
1399
  parsedBody,
1419
- exceptionCtor: __BaseException,
1420
1400
  errorCode,
1421
1401
  });
1422
1402
  }
@@ -1427,12 +1407,12 @@ export const de_DeleteRegexPatternSetCommand = async (output, context) => {
1427
1407
  }
1428
1408
  const data = await parseBody(output.body, context);
1429
1409
  let contents = {};
1430
- contents = de_DeleteRegexPatternSetResponse(data, context);
1410
+ contents = _json(data);
1431
1411
  const response = {
1432
1412
  $metadata: deserializeMetadata(output),
1433
1413
  ...contents,
1434
1414
  };
1435
- return Promise.resolve(response);
1415
+ return response;
1436
1416
  };
1437
1417
  const de_DeleteRegexPatternSetCommandError = async (output, context) => {
1438
1418
  const parsedOutput = {
@@ -1461,10 +1441,9 @@ const de_DeleteRegexPatternSetCommandError = async (output, context) => {
1461
1441
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1462
1442
  default:
1463
1443
  const parsedBody = parsedOutput.body;
1464
- throwDefaultError({
1444
+ return throwDefaultError({
1465
1445
  output,
1466
1446
  parsedBody,
1467
- exceptionCtor: __BaseException,
1468
1447
  errorCode,
1469
1448
  });
1470
1449
  }
@@ -1475,12 +1454,12 @@ export const de_DeleteRuleCommand = async (output, context) => {
1475
1454
  }
1476
1455
  const data = await parseBody(output.body, context);
1477
1456
  let contents = {};
1478
- contents = de_DeleteRuleResponse(data, context);
1457
+ contents = _json(data);
1479
1458
  const response = {
1480
1459
  $metadata: deserializeMetadata(output),
1481
1460
  ...contents,
1482
1461
  };
1483
- return Promise.resolve(response);
1462
+ return response;
1484
1463
  };
1485
1464
  const de_DeleteRuleCommandError = async (output, context) => {
1486
1465
  const parsedOutput = {
@@ -1515,10 +1494,9 @@ const de_DeleteRuleCommandError = async (output, context) => {
1515
1494
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
1516
1495
  default:
1517
1496
  const parsedBody = parsedOutput.body;
1518
- throwDefaultError({
1497
+ return throwDefaultError({
1519
1498
  output,
1520
1499
  parsedBody,
1521
- exceptionCtor: __BaseException,
1522
1500
  errorCode,
1523
1501
  });
1524
1502
  }
@@ -1529,12 +1507,12 @@ export const de_DeleteRuleGroupCommand = async (output, context) => {
1529
1507
  }
1530
1508
  const data = await parseBody(output.body, context);
1531
1509
  let contents = {};
1532
- contents = de_DeleteRuleGroupResponse(data, context);
1510
+ contents = _json(data);
1533
1511
  const response = {
1534
1512
  $metadata: deserializeMetadata(output),
1535
1513
  ...contents,
1536
1514
  };
1537
- return Promise.resolve(response);
1515
+ return response;
1538
1516
  };
1539
1517
  const de_DeleteRuleGroupCommandError = async (output, context) => {
1540
1518
  const parsedOutput = {
@@ -1569,10 +1547,9 @@ const de_DeleteRuleGroupCommandError = async (output, context) => {
1569
1547
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
1570
1548
  default:
1571
1549
  const parsedBody = parsedOutput.body;
1572
- throwDefaultError({
1550
+ return throwDefaultError({
1573
1551
  output,
1574
1552
  parsedBody,
1575
- exceptionCtor: __BaseException,
1576
1553
  errorCode,
1577
1554
  });
1578
1555
  }
@@ -1583,12 +1560,12 @@ export const de_DeleteSizeConstraintSetCommand = async (output, context) => {
1583
1560
  }
1584
1561
  const data = await parseBody(output.body, context);
1585
1562
  let contents = {};
1586
- contents = de_DeleteSizeConstraintSetResponse(data, context);
1563
+ contents = _json(data);
1587
1564
  const response = {
1588
1565
  $metadata: deserializeMetadata(output),
1589
1566
  ...contents,
1590
1567
  };
1591
- return Promise.resolve(response);
1568
+ return response;
1592
1569
  };
1593
1570
  const de_DeleteSizeConstraintSetCommandError = async (output, context) => {
1594
1571
  const parsedOutput = {
@@ -1617,10 +1594,9 @@ const de_DeleteSizeConstraintSetCommandError = async (output, context) => {
1617
1594
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1618
1595
  default:
1619
1596
  const parsedBody = parsedOutput.body;
1620
- throwDefaultError({
1597
+ return throwDefaultError({
1621
1598
  output,
1622
1599
  parsedBody,
1623
- exceptionCtor: __BaseException,
1624
1600
  errorCode,
1625
1601
  });
1626
1602
  }
@@ -1631,12 +1607,12 @@ export const de_DeleteSqlInjectionMatchSetCommand = async (output, context) => {
1631
1607
  }
1632
1608
  const data = await parseBody(output.body, context);
1633
1609
  let contents = {};
1634
- contents = de_DeleteSqlInjectionMatchSetResponse(data, context);
1610
+ contents = _json(data);
1635
1611
  const response = {
1636
1612
  $metadata: deserializeMetadata(output),
1637
1613
  ...contents,
1638
1614
  };
1639
- return Promise.resolve(response);
1615
+ return response;
1640
1616
  };
1641
1617
  const de_DeleteSqlInjectionMatchSetCommandError = async (output, context) => {
1642
1618
  const parsedOutput = {
@@ -1665,10 +1641,9 @@ const de_DeleteSqlInjectionMatchSetCommandError = async (output, context) => {
1665
1641
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1666
1642
  default:
1667
1643
  const parsedBody = parsedOutput.body;
1668
- throwDefaultError({
1644
+ return throwDefaultError({
1669
1645
  output,
1670
1646
  parsedBody,
1671
- exceptionCtor: __BaseException,
1672
1647
  errorCode,
1673
1648
  });
1674
1649
  }
@@ -1679,12 +1654,12 @@ export const de_DeleteWebACLCommand = async (output, context) => {
1679
1654
  }
1680
1655
  const data = await parseBody(output.body, context);
1681
1656
  let contents = {};
1682
- contents = de_DeleteWebACLResponse(data, context);
1657
+ contents = _json(data);
1683
1658
  const response = {
1684
1659
  $metadata: deserializeMetadata(output),
1685
1660
  ...contents,
1686
1661
  };
1687
- return Promise.resolve(response);
1662
+ return response;
1688
1663
  };
1689
1664
  const de_DeleteWebACLCommandError = async (output, context) => {
1690
1665
  const parsedOutput = {
@@ -1719,10 +1694,9 @@ const de_DeleteWebACLCommandError = async (output, context) => {
1719
1694
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
1720
1695
  default:
1721
1696
  const parsedBody = parsedOutput.body;
1722
- throwDefaultError({
1697
+ return throwDefaultError({
1723
1698
  output,
1724
1699
  parsedBody,
1725
- exceptionCtor: __BaseException,
1726
1700
  errorCode,
1727
1701
  });
1728
1702
  }
@@ -1733,12 +1707,12 @@ export const de_DeleteXssMatchSetCommand = async (output, context) => {
1733
1707
  }
1734
1708
  const data = await parseBody(output.body, context);
1735
1709
  let contents = {};
1736
- contents = de_DeleteXssMatchSetResponse(data, context);
1710
+ contents = _json(data);
1737
1711
  const response = {
1738
1712
  $metadata: deserializeMetadata(output),
1739
1713
  ...contents,
1740
1714
  };
1741
- return Promise.resolve(response);
1715
+ return response;
1742
1716
  };
1743
1717
  const de_DeleteXssMatchSetCommandError = async (output, context) => {
1744
1718
  const parsedOutput = {
@@ -1767,10 +1741,9 @@ const de_DeleteXssMatchSetCommandError = async (output, context) => {
1767
1741
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1768
1742
  default:
1769
1743
  const parsedBody = parsedOutput.body;
1770
- throwDefaultError({
1744
+ return throwDefaultError({
1771
1745
  output,
1772
1746
  parsedBody,
1773
- exceptionCtor: __BaseException,
1774
1747
  errorCode,
1775
1748
  });
1776
1749
  }
@@ -1786,7 +1759,7 @@ export const de_GetByteMatchSetCommand = async (output, context) => {
1786
1759
  $metadata: deserializeMetadata(output),
1787
1760
  ...contents,
1788
1761
  };
1789
- return Promise.resolve(response);
1762
+ return response;
1790
1763
  };
1791
1764
  const de_GetByteMatchSetCommandError = async (output, context) => {
1792
1765
  const parsedOutput = {
@@ -1806,10 +1779,9 @@ const de_GetByteMatchSetCommandError = async (output, context) => {
1806
1779
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
1807
1780
  default:
1808
1781
  const parsedBody = parsedOutput.body;
1809
- throwDefaultError({
1782
+ return throwDefaultError({
1810
1783
  output,
1811
1784
  parsedBody,
1812
- exceptionCtor: __BaseException,
1813
1785
  errorCode,
1814
1786
  });
1815
1787
  }
@@ -1820,12 +1792,12 @@ export const de_GetChangeTokenCommand = async (output, context) => {
1820
1792
  }
1821
1793
  const data = await parseBody(output.body, context);
1822
1794
  let contents = {};
1823
- contents = de_GetChangeTokenResponse(data, context);
1795
+ contents = _json(data);
1824
1796
  const response = {
1825
1797
  $metadata: deserializeMetadata(output),
1826
1798
  ...contents,
1827
1799
  };
1828
- return Promise.resolve(response);
1800
+ return response;
1829
1801
  };
1830
1802
  const de_GetChangeTokenCommandError = async (output, context) => {
1831
1803
  const parsedOutput = {
@@ -1839,10 +1811,9 @@ const de_GetChangeTokenCommandError = async (output, context) => {
1839
1811
  throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
1840
1812
  default:
1841
1813
  const parsedBody = parsedOutput.body;
1842
- throwDefaultError({
1814
+ return throwDefaultError({
1843
1815
  output,
1844
1816
  parsedBody,
1845
- exceptionCtor: __BaseException,
1846
1817
  errorCode,
1847
1818
  });
1848
1819
  }
@@ -1853,12 +1824,12 @@ export const de_GetChangeTokenStatusCommand = async (output, context) => {
1853
1824
  }
1854
1825
  const data = await parseBody(output.body, context);
1855
1826
  let contents = {};
1856
- contents = de_GetChangeTokenStatusResponse(data, context);
1827
+ contents = _json(data);
1857
1828
  const response = {
1858
1829
  $metadata: deserializeMetadata(output),
1859
1830
  ...contents,
1860
1831
  };
1861
- return Promise.resolve(response);
1832
+ return response;
1862
1833
  };
1863
1834
  const de_GetChangeTokenStatusCommandError = async (output, context) => {
1864
1835
  const parsedOutput = {
@@ -1875,10 +1846,9 @@ const de_GetChangeTokenStatusCommandError = async (output, context) => {
1875
1846
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
1876
1847
  default:
1877
1848
  const parsedBody = parsedOutput.body;
1878
- throwDefaultError({
1849
+ return throwDefaultError({
1879
1850
  output,
1880
1851
  parsedBody,
1881
- exceptionCtor: __BaseException,
1882
1852
  errorCode,
1883
1853
  });
1884
1854
  }
@@ -1889,12 +1859,12 @@ export const de_GetGeoMatchSetCommand = async (output, context) => {
1889
1859
  }
1890
1860
  const data = await parseBody(output.body, context);
1891
1861
  let contents = {};
1892
- contents = de_GetGeoMatchSetResponse(data, context);
1862
+ contents = _json(data);
1893
1863
  const response = {
1894
1864
  $metadata: deserializeMetadata(output),
1895
1865
  ...contents,
1896
1866
  };
1897
- return Promise.resolve(response);
1867
+ return response;
1898
1868
  };
1899
1869
  const de_GetGeoMatchSetCommandError = async (output, context) => {
1900
1870
  const parsedOutput = {
@@ -1914,10 +1884,9 @@ const de_GetGeoMatchSetCommandError = async (output, context) => {
1914
1884
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
1915
1885
  default:
1916
1886
  const parsedBody = parsedOutput.body;
1917
- throwDefaultError({
1887
+ return throwDefaultError({
1918
1888
  output,
1919
1889
  parsedBody,
1920
- exceptionCtor: __BaseException,
1921
1890
  errorCode,
1922
1891
  });
1923
1892
  }
@@ -1928,12 +1897,12 @@ export const de_GetIPSetCommand = async (output, context) => {
1928
1897
  }
1929
1898
  const data = await parseBody(output.body, context);
1930
1899
  let contents = {};
1931
- contents = de_GetIPSetResponse(data, context);
1900
+ contents = _json(data);
1932
1901
  const response = {
1933
1902
  $metadata: deserializeMetadata(output),
1934
1903
  ...contents,
1935
1904
  };
1936
- return Promise.resolve(response);
1905
+ return response;
1937
1906
  };
1938
1907
  const de_GetIPSetCommandError = async (output, context) => {
1939
1908
  const parsedOutput = {
@@ -1953,10 +1922,9 @@ const de_GetIPSetCommandError = async (output, context) => {
1953
1922
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
1954
1923
  default:
1955
1924
  const parsedBody = parsedOutput.body;
1956
- throwDefaultError({
1925
+ return throwDefaultError({
1957
1926
  output,
1958
1927
  parsedBody,
1959
- exceptionCtor: __BaseException,
1960
1928
  errorCode,
1961
1929
  });
1962
1930
  }
@@ -1967,12 +1935,12 @@ export const de_GetLoggingConfigurationCommand = async (output, context) => {
1967
1935
  }
1968
1936
  const data = await parseBody(output.body, context);
1969
1937
  let contents = {};
1970
- contents = de_GetLoggingConfigurationResponse(data, context);
1938
+ contents = _json(data);
1971
1939
  const response = {
1972
1940
  $metadata: deserializeMetadata(output),
1973
1941
  ...contents,
1974
1942
  };
1975
- return Promise.resolve(response);
1943
+ return response;
1976
1944
  };
1977
1945
  const de_GetLoggingConfigurationCommandError = async (output, context) => {
1978
1946
  const parsedOutput = {
@@ -1989,10 +1957,9 @@ const de_GetLoggingConfigurationCommandError = async (output, context) => {
1989
1957
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
1990
1958
  default:
1991
1959
  const parsedBody = parsedOutput.body;
1992
- throwDefaultError({
1960
+ return throwDefaultError({
1993
1961
  output,
1994
1962
  parsedBody,
1995
- exceptionCtor: __BaseException,
1996
1963
  errorCode,
1997
1964
  });
1998
1965
  }
@@ -2003,12 +1970,12 @@ export const de_GetPermissionPolicyCommand = async (output, context) => {
2003
1970
  }
2004
1971
  const data = await parseBody(output.body, context);
2005
1972
  let contents = {};
2006
- contents = de_GetPermissionPolicyResponse(data, context);
1973
+ contents = _json(data);
2007
1974
  const response = {
2008
1975
  $metadata: deserializeMetadata(output),
2009
1976
  ...contents,
2010
1977
  };
2011
- return Promise.resolve(response);
1978
+ return response;
2012
1979
  };
2013
1980
  const de_GetPermissionPolicyCommandError = async (output, context) => {
2014
1981
  const parsedOutput = {
@@ -2025,10 +1992,9 @@ const de_GetPermissionPolicyCommandError = async (output, context) => {
2025
1992
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2026
1993
  default:
2027
1994
  const parsedBody = parsedOutput.body;
2028
- throwDefaultError({
1995
+ return throwDefaultError({
2029
1996
  output,
2030
1997
  parsedBody,
2031
- exceptionCtor: __BaseException,
2032
1998
  errorCode,
2033
1999
  });
2034
2000
  }
@@ -2039,12 +2005,12 @@ export const de_GetRateBasedRuleCommand = async (output, context) => {
2039
2005
  }
2040
2006
  const data = await parseBody(output.body, context);
2041
2007
  let contents = {};
2042
- contents = de_GetRateBasedRuleResponse(data, context);
2008
+ contents = _json(data);
2043
2009
  const response = {
2044
2010
  $metadata: deserializeMetadata(output),
2045
2011
  ...contents,
2046
2012
  };
2047
- return Promise.resolve(response);
2013
+ return response;
2048
2014
  };
2049
2015
  const de_GetRateBasedRuleCommandError = async (output, context) => {
2050
2016
  const parsedOutput = {
@@ -2064,10 +2030,9 @@ const de_GetRateBasedRuleCommandError = async (output, context) => {
2064
2030
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2065
2031
  default:
2066
2032
  const parsedBody = parsedOutput.body;
2067
- throwDefaultError({
2033
+ return throwDefaultError({
2068
2034
  output,
2069
2035
  parsedBody,
2070
- exceptionCtor: __BaseException,
2071
2036
  errorCode,
2072
2037
  });
2073
2038
  }
@@ -2078,12 +2043,12 @@ export const de_GetRateBasedRuleManagedKeysCommand = async (output, context) =>
2078
2043
  }
2079
2044
  const data = await parseBody(output.body, context);
2080
2045
  let contents = {};
2081
- contents = de_GetRateBasedRuleManagedKeysResponse(data, context);
2046
+ contents = _json(data);
2082
2047
  const response = {
2083
2048
  $metadata: deserializeMetadata(output),
2084
2049
  ...contents,
2085
2050
  };
2086
- return Promise.resolve(response);
2051
+ return response;
2087
2052
  };
2088
2053
  const de_GetRateBasedRuleManagedKeysCommandError = async (output, context) => {
2089
2054
  const parsedOutput = {
@@ -2106,10 +2071,9 @@ const de_GetRateBasedRuleManagedKeysCommandError = async (output, context) => {
2106
2071
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2107
2072
  default:
2108
2073
  const parsedBody = parsedOutput.body;
2109
- throwDefaultError({
2074
+ return throwDefaultError({
2110
2075
  output,
2111
2076
  parsedBody,
2112
- exceptionCtor: __BaseException,
2113
2077
  errorCode,
2114
2078
  });
2115
2079
  }
@@ -2120,12 +2084,12 @@ export const de_GetRegexMatchSetCommand = async (output, context) => {
2120
2084
  }
2121
2085
  const data = await parseBody(output.body, context);
2122
2086
  let contents = {};
2123
- contents = de_GetRegexMatchSetResponse(data, context);
2087
+ contents = _json(data);
2124
2088
  const response = {
2125
2089
  $metadata: deserializeMetadata(output),
2126
2090
  ...contents,
2127
2091
  };
2128
- return Promise.resolve(response);
2092
+ return response;
2129
2093
  };
2130
2094
  const de_GetRegexMatchSetCommandError = async (output, context) => {
2131
2095
  const parsedOutput = {
@@ -2145,10 +2109,9 @@ const de_GetRegexMatchSetCommandError = async (output, context) => {
2145
2109
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2146
2110
  default:
2147
2111
  const parsedBody = parsedOutput.body;
2148
- throwDefaultError({
2112
+ return throwDefaultError({
2149
2113
  output,
2150
2114
  parsedBody,
2151
- exceptionCtor: __BaseException,
2152
2115
  errorCode,
2153
2116
  });
2154
2117
  }
@@ -2159,12 +2122,12 @@ export const de_GetRegexPatternSetCommand = async (output, context) => {
2159
2122
  }
2160
2123
  const data = await parseBody(output.body, context);
2161
2124
  let contents = {};
2162
- contents = de_GetRegexPatternSetResponse(data, context);
2125
+ contents = _json(data);
2163
2126
  const response = {
2164
2127
  $metadata: deserializeMetadata(output),
2165
2128
  ...contents,
2166
2129
  };
2167
- return Promise.resolve(response);
2130
+ return response;
2168
2131
  };
2169
2132
  const de_GetRegexPatternSetCommandError = async (output, context) => {
2170
2133
  const parsedOutput = {
@@ -2184,10 +2147,9 @@ const de_GetRegexPatternSetCommandError = async (output, context) => {
2184
2147
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2185
2148
  default:
2186
2149
  const parsedBody = parsedOutput.body;
2187
- throwDefaultError({
2150
+ return throwDefaultError({
2188
2151
  output,
2189
2152
  parsedBody,
2190
- exceptionCtor: __BaseException,
2191
2153
  errorCode,
2192
2154
  });
2193
2155
  }
@@ -2198,12 +2160,12 @@ export const de_GetRuleCommand = async (output, context) => {
2198
2160
  }
2199
2161
  const data = await parseBody(output.body, context);
2200
2162
  let contents = {};
2201
- contents = de_GetRuleResponse(data, context);
2163
+ contents = _json(data);
2202
2164
  const response = {
2203
2165
  $metadata: deserializeMetadata(output),
2204
2166
  ...contents,
2205
2167
  };
2206
- return Promise.resolve(response);
2168
+ return response;
2207
2169
  };
2208
2170
  const de_GetRuleCommandError = async (output, context) => {
2209
2171
  const parsedOutput = {
@@ -2223,10 +2185,9 @@ const de_GetRuleCommandError = async (output, context) => {
2223
2185
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2224
2186
  default:
2225
2187
  const parsedBody = parsedOutput.body;
2226
- throwDefaultError({
2188
+ return throwDefaultError({
2227
2189
  output,
2228
2190
  parsedBody,
2229
- exceptionCtor: __BaseException,
2230
2191
  errorCode,
2231
2192
  });
2232
2193
  }
@@ -2237,12 +2198,12 @@ export const de_GetRuleGroupCommand = async (output, context) => {
2237
2198
  }
2238
2199
  const data = await parseBody(output.body, context);
2239
2200
  let contents = {};
2240
- contents = de_GetRuleGroupResponse(data, context);
2201
+ contents = _json(data);
2241
2202
  const response = {
2242
2203
  $metadata: deserializeMetadata(output),
2243
2204
  ...contents,
2244
2205
  };
2245
- return Promise.resolve(response);
2206
+ return response;
2246
2207
  };
2247
2208
  const de_GetRuleGroupCommandError = async (output, context) => {
2248
2209
  const parsedOutput = {
@@ -2259,10 +2220,9 @@ const de_GetRuleGroupCommandError = async (output, context) => {
2259
2220
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2260
2221
  default:
2261
2222
  const parsedBody = parsedOutput.body;
2262
- throwDefaultError({
2223
+ return throwDefaultError({
2263
2224
  output,
2264
2225
  parsedBody,
2265
- exceptionCtor: __BaseException,
2266
2226
  errorCode,
2267
2227
  });
2268
2228
  }
@@ -2278,7 +2238,7 @@ export const de_GetSampledRequestsCommand = async (output, context) => {
2278
2238
  $metadata: deserializeMetadata(output),
2279
2239
  ...contents,
2280
2240
  };
2281
- return Promise.resolve(response);
2241
+ return response;
2282
2242
  };
2283
2243
  const de_GetSampledRequestsCommandError = async (output, context) => {
2284
2244
  const parsedOutput = {
@@ -2295,10 +2255,9 @@ const de_GetSampledRequestsCommandError = async (output, context) => {
2295
2255
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2296
2256
  default:
2297
2257
  const parsedBody = parsedOutput.body;
2298
- throwDefaultError({
2258
+ return throwDefaultError({
2299
2259
  output,
2300
2260
  parsedBody,
2301
- exceptionCtor: __BaseException,
2302
2261
  errorCode,
2303
2262
  });
2304
2263
  }
@@ -2309,12 +2268,12 @@ export const de_GetSizeConstraintSetCommand = async (output, context) => {
2309
2268
  }
2310
2269
  const data = await parseBody(output.body, context);
2311
2270
  let contents = {};
2312
- contents = de_GetSizeConstraintSetResponse(data, context);
2271
+ contents = _json(data);
2313
2272
  const response = {
2314
2273
  $metadata: deserializeMetadata(output),
2315
2274
  ...contents,
2316
2275
  };
2317
- return Promise.resolve(response);
2276
+ return response;
2318
2277
  };
2319
2278
  const de_GetSizeConstraintSetCommandError = async (output, context) => {
2320
2279
  const parsedOutput = {
@@ -2334,10 +2293,9 @@ const de_GetSizeConstraintSetCommandError = async (output, context) => {
2334
2293
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2335
2294
  default:
2336
2295
  const parsedBody = parsedOutput.body;
2337
- throwDefaultError({
2296
+ return throwDefaultError({
2338
2297
  output,
2339
2298
  parsedBody,
2340
- exceptionCtor: __BaseException,
2341
2299
  errorCode,
2342
2300
  });
2343
2301
  }
@@ -2348,12 +2306,12 @@ export const de_GetSqlInjectionMatchSetCommand = async (output, context) => {
2348
2306
  }
2349
2307
  const data = await parseBody(output.body, context);
2350
2308
  let contents = {};
2351
- contents = de_GetSqlInjectionMatchSetResponse(data, context);
2309
+ contents = _json(data);
2352
2310
  const response = {
2353
2311
  $metadata: deserializeMetadata(output),
2354
2312
  ...contents,
2355
2313
  };
2356
- return Promise.resolve(response);
2314
+ return response;
2357
2315
  };
2358
2316
  const de_GetSqlInjectionMatchSetCommandError = async (output, context) => {
2359
2317
  const parsedOutput = {
@@ -2373,10 +2331,9 @@ const de_GetSqlInjectionMatchSetCommandError = async (output, context) => {
2373
2331
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2374
2332
  default:
2375
2333
  const parsedBody = parsedOutput.body;
2376
- throwDefaultError({
2334
+ return throwDefaultError({
2377
2335
  output,
2378
2336
  parsedBody,
2379
- exceptionCtor: __BaseException,
2380
2337
  errorCode,
2381
2338
  });
2382
2339
  }
@@ -2387,12 +2344,12 @@ export const de_GetWebACLCommand = async (output, context) => {
2387
2344
  }
2388
2345
  const data = await parseBody(output.body, context);
2389
2346
  let contents = {};
2390
- contents = de_GetWebACLResponse(data, context);
2347
+ contents = _json(data);
2391
2348
  const response = {
2392
2349
  $metadata: deserializeMetadata(output),
2393
2350
  ...contents,
2394
2351
  };
2395
- return Promise.resolve(response);
2352
+ return response;
2396
2353
  };
2397
2354
  const de_GetWebACLCommandError = async (output, context) => {
2398
2355
  const parsedOutput = {
@@ -2412,10 +2369,9 @@ const de_GetWebACLCommandError = async (output, context) => {
2412
2369
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2413
2370
  default:
2414
2371
  const parsedBody = parsedOutput.body;
2415
- throwDefaultError({
2372
+ return throwDefaultError({
2416
2373
  output,
2417
2374
  parsedBody,
2418
- exceptionCtor: __BaseException,
2419
2375
  errorCode,
2420
2376
  });
2421
2377
  }
@@ -2426,12 +2382,12 @@ export const de_GetXssMatchSetCommand = async (output, context) => {
2426
2382
  }
2427
2383
  const data = await parseBody(output.body, context);
2428
2384
  let contents = {};
2429
- contents = de_GetXssMatchSetResponse(data, context);
2385
+ contents = _json(data);
2430
2386
  const response = {
2431
2387
  $metadata: deserializeMetadata(output),
2432
2388
  ...contents,
2433
2389
  };
2434
- return Promise.resolve(response);
2390
+ return response;
2435
2391
  };
2436
2392
  const de_GetXssMatchSetCommandError = async (output, context) => {
2437
2393
  const parsedOutput = {
@@ -2451,10 +2407,9 @@ const de_GetXssMatchSetCommandError = async (output, context) => {
2451
2407
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2452
2408
  default:
2453
2409
  const parsedBody = parsedOutput.body;
2454
- throwDefaultError({
2410
+ return throwDefaultError({
2455
2411
  output,
2456
2412
  parsedBody,
2457
- exceptionCtor: __BaseException,
2458
2413
  errorCode,
2459
2414
  });
2460
2415
  }
@@ -2465,12 +2420,12 @@ export const de_ListActivatedRulesInRuleGroupCommand = async (output, context) =
2465
2420
  }
2466
2421
  const data = await parseBody(output.body, context);
2467
2422
  let contents = {};
2468
- contents = de_ListActivatedRulesInRuleGroupResponse(data, context);
2423
+ contents = _json(data);
2469
2424
  const response = {
2470
2425
  $metadata: deserializeMetadata(output),
2471
2426
  ...contents,
2472
2427
  };
2473
- return Promise.resolve(response);
2428
+ return response;
2474
2429
  };
2475
2430
  const de_ListActivatedRulesInRuleGroupCommandError = async (output, context) => {
2476
2431
  const parsedOutput = {
@@ -2490,10 +2445,9 @@ const de_ListActivatedRulesInRuleGroupCommandError = async (output, context) =>
2490
2445
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2491
2446
  default:
2492
2447
  const parsedBody = parsedOutput.body;
2493
- throwDefaultError({
2448
+ return throwDefaultError({
2494
2449
  output,
2495
2450
  parsedBody,
2496
- exceptionCtor: __BaseException,
2497
2451
  errorCode,
2498
2452
  });
2499
2453
  }
@@ -2504,12 +2458,12 @@ export const de_ListByteMatchSetsCommand = async (output, context) => {
2504
2458
  }
2505
2459
  const data = await parseBody(output.body, context);
2506
2460
  let contents = {};
2507
- contents = de_ListByteMatchSetsResponse(data, context);
2461
+ contents = _json(data);
2508
2462
  const response = {
2509
2463
  $metadata: deserializeMetadata(output),
2510
2464
  ...contents,
2511
2465
  };
2512
- return Promise.resolve(response);
2466
+ return response;
2513
2467
  };
2514
2468
  const de_ListByteMatchSetsCommandError = async (output, context) => {
2515
2469
  const parsedOutput = {
@@ -2526,10 +2480,9 @@ const de_ListByteMatchSetsCommandError = async (output, context) => {
2526
2480
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
2527
2481
  default:
2528
2482
  const parsedBody = parsedOutput.body;
2529
- throwDefaultError({
2483
+ return throwDefaultError({
2530
2484
  output,
2531
2485
  parsedBody,
2532
- exceptionCtor: __BaseException,
2533
2486
  errorCode,
2534
2487
  });
2535
2488
  }
@@ -2540,12 +2493,12 @@ export const de_ListGeoMatchSetsCommand = async (output, context) => {
2540
2493
  }
2541
2494
  const data = await parseBody(output.body, context);
2542
2495
  let contents = {};
2543
- contents = de_ListGeoMatchSetsResponse(data, context);
2496
+ contents = _json(data);
2544
2497
  const response = {
2545
2498
  $metadata: deserializeMetadata(output),
2546
2499
  ...contents,
2547
2500
  };
2548
- return Promise.resolve(response);
2501
+ return response;
2549
2502
  };
2550
2503
  const de_ListGeoMatchSetsCommandError = async (output, context) => {
2551
2504
  const parsedOutput = {
@@ -2562,10 +2515,9 @@ const de_ListGeoMatchSetsCommandError = async (output, context) => {
2562
2515
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
2563
2516
  default:
2564
2517
  const parsedBody = parsedOutput.body;
2565
- throwDefaultError({
2518
+ return throwDefaultError({
2566
2519
  output,
2567
2520
  parsedBody,
2568
- exceptionCtor: __BaseException,
2569
2521
  errorCode,
2570
2522
  });
2571
2523
  }
@@ -2576,12 +2528,12 @@ export const de_ListIPSetsCommand = async (output, context) => {
2576
2528
  }
2577
2529
  const data = await parseBody(output.body, context);
2578
2530
  let contents = {};
2579
- contents = de_ListIPSetsResponse(data, context);
2531
+ contents = _json(data);
2580
2532
  const response = {
2581
2533
  $metadata: deserializeMetadata(output),
2582
2534
  ...contents,
2583
2535
  };
2584
- return Promise.resolve(response);
2536
+ return response;
2585
2537
  };
2586
2538
  const de_ListIPSetsCommandError = async (output, context) => {
2587
2539
  const parsedOutput = {
@@ -2598,10 +2550,9 @@ const de_ListIPSetsCommandError = async (output, context) => {
2598
2550
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
2599
2551
  default:
2600
2552
  const parsedBody = parsedOutput.body;
2601
- throwDefaultError({
2553
+ return throwDefaultError({
2602
2554
  output,
2603
2555
  parsedBody,
2604
- exceptionCtor: __BaseException,
2605
2556
  errorCode,
2606
2557
  });
2607
2558
  }
@@ -2612,12 +2563,12 @@ export const de_ListLoggingConfigurationsCommand = async (output, context) => {
2612
2563
  }
2613
2564
  const data = await parseBody(output.body, context);
2614
2565
  let contents = {};
2615
- contents = de_ListLoggingConfigurationsResponse(data, context);
2566
+ contents = _json(data);
2616
2567
  const response = {
2617
2568
  $metadata: deserializeMetadata(output),
2618
2569
  ...contents,
2619
2570
  };
2620
- return Promise.resolve(response);
2571
+ return response;
2621
2572
  };
2622
2573
  const de_ListLoggingConfigurationsCommandError = async (output, context) => {
2623
2574
  const parsedOutput = {
@@ -2637,10 +2588,9 @@ const de_ListLoggingConfigurationsCommandError = async (output, context) => {
2637
2588
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2638
2589
  default:
2639
2590
  const parsedBody = parsedOutput.body;
2640
- throwDefaultError({
2591
+ return throwDefaultError({
2641
2592
  output,
2642
2593
  parsedBody,
2643
- exceptionCtor: __BaseException,
2644
2594
  errorCode,
2645
2595
  });
2646
2596
  }
@@ -2651,12 +2601,12 @@ export const de_ListRateBasedRulesCommand = async (output, context) => {
2651
2601
  }
2652
2602
  const data = await parseBody(output.body, context);
2653
2603
  let contents = {};
2654
- contents = de_ListRateBasedRulesResponse(data, context);
2604
+ contents = _json(data);
2655
2605
  const response = {
2656
2606
  $metadata: deserializeMetadata(output),
2657
2607
  ...contents,
2658
2608
  };
2659
- return Promise.resolve(response);
2609
+ return response;
2660
2610
  };
2661
2611
  const de_ListRateBasedRulesCommandError = async (output, context) => {
2662
2612
  const parsedOutput = {
@@ -2673,10 +2623,9 @@ const de_ListRateBasedRulesCommandError = async (output, context) => {
2673
2623
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
2674
2624
  default:
2675
2625
  const parsedBody = parsedOutput.body;
2676
- throwDefaultError({
2626
+ return throwDefaultError({
2677
2627
  output,
2678
2628
  parsedBody,
2679
- exceptionCtor: __BaseException,
2680
2629
  errorCode,
2681
2630
  });
2682
2631
  }
@@ -2687,12 +2636,12 @@ export const de_ListRegexMatchSetsCommand = async (output, context) => {
2687
2636
  }
2688
2637
  const data = await parseBody(output.body, context);
2689
2638
  let contents = {};
2690
- contents = de_ListRegexMatchSetsResponse(data, context);
2639
+ contents = _json(data);
2691
2640
  const response = {
2692
2641
  $metadata: deserializeMetadata(output),
2693
2642
  ...contents,
2694
2643
  };
2695
- return Promise.resolve(response);
2644
+ return response;
2696
2645
  };
2697
2646
  const de_ListRegexMatchSetsCommandError = async (output, context) => {
2698
2647
  const parsedOutput = {
@@ -2709,10 +2658,9 @@ const de_ListRegexMatchSetsCommandError = async (output, context) => {
2709
2658
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
2710
2659
  default:
2711
2660
  const parsedBody = parsedOutput.body;
2712
- throwDefaultError({
2661
+ return throwDefaultError({
2713
2662
  output,
2714
2663
  parsedBody,
2715
- exceptionCtor: __BaseException,
2716
2664
  errorCode,
2717
2665
  });
2718
2666
  }
@@ -2723,12 +2671,12 @@ export const de_ListRegexPatternSetsCommand = async (output, context) => {
2723
2671
  }
2724
2672
  const data = await parseBody(output.body, context);
2725
2673
  let contents = {};
2726
- contents = de_ListRegexPatternSetsResponse(data, context);
2674
+ contents = _json(data);
2727
2675
  const response = {
2728
2676
  $metadata: deserializeMetadata(output),
2729
2677
  ...contents,
2730
2678
  };
2731
- return Promise.resolve(response);
2679
+ return response;
2732
2680
  };
2733
2681
  const de_ListRegexPatternSetsCommandError = async (output, context) => {
2734
2682
  const parsedOutput = {
@@ -2745,10 +2693,9 @@ const de_ListRegexPatternSetsCommandError = async (output, context) => {
2745
2693
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
2746
2694
  default:
2747
2695
  const parsedBody = parsedOutput.body;
2748
- throwDefaultError({
2696
+ return throwDefaultError({
2749
2697
  output,
2750
2698
  parsedBody,
2751
- exceptionCtor: __BaseException,
2752
2699
  errorCode,
2753
2700
  });
2754
2701
  }
@@ -2759,12 +2706,12 @@ export const de_ListRuleGroupsCommand = async (output, context) => {
2759
2706
  }
2760
2707
  const data = await parseBody(output.body, context);
2761
2708
  let contents = {};
2762
- contents = de_ListRuleGroupsResponse(data, context);
2709
+ contents = _json(data);
2763
2710
  const response = {
2764
2711
  $metadata: deserializeMetadata(output),
2765
2712
  ...contents,
2766
2713
  };
2767
- return Promise.resolve(response);
2714
+ return response;
2768
2715
  };
2769
2716
  const de_ListRuleGroupsCommandError = async (output, context) => {
2770
2717
  const parsedOutput = {
@@ -2778,10 +2725,9 @@ const de_ListRuleGroupsCommandError = async (output, context) => {
2778
2725
  throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
2779
2726
  default:
2780
2727
  const parsedBody = parsedOutput.body;
2781
- throwDefaultError({
2728
+ return throwDefaultError({
2782
2729
  output,
2783
2730
  parsedBody,
2784
- exceptionCtor: __BaseException,
2785
2731
  errorCode,
2786
2732
  });
2787
2733
  }
@@ -2792,12 +2738,12 @@ export const de_ListRulesCommand = async (output, context) => {
2792
2738
  }
2793
2739
  const data = await parseBody(output.body, context);
2794
2740
  let contents = {};
2795
- contents = de_ListRulesResponse(data, context);
2741
+ contents = _json(data);
2796
2742
  const response = {
2797
2743
  $metadata: deserializeMetadata(output),
2798
2744
  ...contents,
2799
2745
  };
2800
- return Promise.resolve(response);
2746
+ return response;
2801
2747
  };
2802
2748
  const de_ListRulesCommandError = async (output, context) => {
2803
2749
  const parsedOutput = {
@@ -2814,10 +2760,9 @@ const de_ListRulesCommandError = async (output, context) => {
2814
2760
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
2815
2761
  default:
2816
2762
  const parsedBody = parsedOutput.body;
2817
- throwDefaultError({
2763
+ return throwDefaultError({
2818
2764
  output,
2819
2765
  parsedBody,
2820
- exceptionCtor: __BaseException,
2821
2766
  errorCode,
2822
2767
  });
2823
2768
  }
@@ -2828,12 +2773,12 @@ export const de_ListSizeConstraintSetsCommand = async (output, context) => {
2828
2773
  }
2829
2774
  const data = await parseBody(output.body, context);
2830
2775
  let contents = {};
2831
- contents = de_ListSizeConstraintSetsResponse(data, context);
2776
+ contents = _json(data);
2832
2777
  const response = {
2833
2778
  $metadata: deserializeMetadata(output),
2834
2779
  ...contents,
2835
2780
  };
2836
- return Promise.resolve(response);
2781
+ return response;
2837
2782
  };
2838
2783
  const de_ListSizeConstraintSetsCommandError = async (output, context) => {
2839
2784
  const parsedOutput = {
@@ -2850,10 +2795,9 @@ const de_ListSizeConstraintSetsCommandError = async (output, context) => {
2850
2795
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
2851
2796
  default:
2852
2797
  const parsedBody = parsedOutput.body;
2853
- throwDefaultError({
2798
+ return throwDefaultError({
2854
2799
  output,
2855
2800
  parsedBody,
2856
- exceptionCtor: __BaseException,
2857
2801
  errorCode,
2858
2802
  });
2859
2803
  }
@@ -2864,12 +2808,12 @@ export const de_ListSqlInjectionMatchSetsCommand = async (output, context) => {
2864
2808
  }
2865
2809
  const data = await parseBody(output.body, context);
2866
2810
  let contents = {};
2867
- contents = de_ListSqlInjectionMatchSetsResponse(data, context);
2811
+ contents = _json(data);
2868
2812
  const response = {
2869
2813
  $metadata: deserializeMetadata(output),
2870
2814
  ...contents,
2871
2815
  };
2872
- return Promise.resolve(response);
2816
+ return response;
2873
2817
  };
2874
2818
  const de_ListSqlInjectionMatchSetsCommandError = async (output, context) => {
2875
2819
  const parsedOutput = {
@@ -2886,10 +2830,9 @@ const de_ListSqlInjectionMatchSetsCommandError = async (output, context) => {
2886
2830
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
2887
2831
  default:
2888
2832
  const parsedBody = parsedOutput.body;
2889
- throwDefaultError({
2833
+ return throwDefaultError({
2890
2834
  output,
2891
2835
  parsedBody,
2892
- exceptionCtor: __BaseException,
2893
2836
  errorCode,
2894
2837
  });
2895
2838
  }
@@ -2900,12 +2843,12 @@ export const de_ListSubscribedRuleGroupsCommand = async (output, context) => {
2900
2843
  }
2901
2844
  const data = await parseBody(output.body, context);
2902
2845
  let contents = {};
2903
- contents = de_ListSubscribedRuleGroupsResponse(data, context);
2846
+ contents = _json(data);
2904
2847
  const response = {
2905
2848
  $metadata: deserializeMetadata(output),
2906
2849
  ...contents,
2907
2850
  };
2908
- return Promise.resolve(response);
2851
+ return response;
2909
2852
  };
2910
2853
  const de_ListSubscribedRuleGroupsCommandError = async (output, context) => {
2911
2854
  const parsedOutput = {
@@ -2922,10 +2865,9 @@ const de_ListSubscribedRuleGroupsCommandError = async (output, context) => {
2922
2865
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2923
2866
  default:
2924
2867
  const parsedBody = parsedOutput.body;
2925
- throwDefaultError({
2868
+ return throwDefaultError({
2926
2869
  output,
2927
2870
  parsedBody,
2928
- exceptionCtor: __BaseException,
2929
2871
  errorCode,
2930
2872
  });
2931
2873
  }
@@ -2936,12 +2878,12 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
2936
2878
  }
2937
2879
  const data = await parseBody(output.body, context);
2938
2880
  let contents = {};
2939
- contents = de_ListTagsForResourceResponse(data, context);
2881
+ contents = _json(data);
2940
2882
  const response = {
2941
2883
  $metadata: deserializeMetadata(output),
2942
2884
  ...contents,
2943
2885
  };
2944
- return Promise.resolve(response);
2886
+ return response;
2945
2887
  };
2946
2888
  const de_ListTagsForResourceCommandError = async (output, context) => {
2947
2889
  const parsedOutput = {
@@ -2970,10 +2912,9 @@ const de_ListTagsForResourceCommandError = async (output, context) => {
2970
2912
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
2971
2913
  default:
2972
2914
  const parsedBody = parsedOutput.body;
2973
- throwDefaultError({
2915
+ return throwDefaultError({
2974
2916
  output,
2975
2917
  parsedBody,
2976
- exceptionCtor: __BaseException,
2977
2918
  errorCode,
2978
2919
  });
2979
2920
  }
@@ -2984,12 +2925,12 @@ export const de_ListWebACLsCommand = async (output, context) => {
2984
2925
  }
2985
2926
  const data = await parseBody(output.body, context);
2986
2927
  let contents = {};
2987
- contents = de_ListWebACLsResponse(data, context);
2928
+ contents = _json(data);
2988
2929
  const response = {
2989
2930
  $metadata: deserializeMetadata(output),
2990
2931
  ...contents,
2991
2932
  };
2992
- return Promise.resolve(response);
2933
+ return response;
2993
2934
  };
2994
2935
  const de_ListWebACLsCommandError = async (output, context) => {
2995
2936
  const parsedOutput = {
@@ -3006,10 +2947,9 @@ const de_ListWebACLsCommandError = async (output, context) => {
3006
2947
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
3007
2948
  default:
3008
2949
  const parsedBody = parsedOutput.body;
3009
- throwDefaultError({
2950
+ return throwDefaultError({
3010
2951
  output,
3011
2952
  parsedBody,
3012
- exceptionCtor: __BaseException,
3013
2953
  errorCode,
3014
2954
  });
3015
2955
  }
@@ -3020,12 +2960,12 @@ export const de_ListXssMatchSetsCommand = async (output, context) => {
3020
2960
  }
3021
2961
  const data = await parseBody(output.body, context);
3022
2962
  let contents = {};
3023
- contents = de_ListXssMatchSetsResponse(data, context);
2963
+ contents = _json(data);
3024
2964
  const response = {
3025
2965
  $metadata: deserializeMetadata(output),
3026
2966
  ...contents,
3027
2967
  };
3028
- return Promise.resolve(response);
2968
+ return response;
3029
2969
  };
3030
2970
  const de_ListXssMatchSetsCommandError = async (output, context) => {
3031
2971
  const parsedOutput = {
@@ -3042,10 +2982,9 @@ const de_ListXssMatchSetsCommandError = async (output, context) => {
3042
2982
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
3043
2983
  default:
3044
2984
  const parsedBody = parsedOutput.body;
3045
- throwDefaultError({
2985
+ return throwDefaultError({
3046
2986
  output,
3047
2987
  parsedBody,
3048
- exceptionCtor: __BaseException,
3049
2988
  errorCode,
3050
2989
  });
3051
2990
  }
@@ -3056,12 +2995,12 @@ export const de_PutLoggingConfigurationCommand = async (output, context) => {
3056
2995
  }
3057
2996
  const data = await parseBody(output.body, context);
3058
2997
  let contents = {};
3059
- contents = de_PutLoggingConfigurationResponse(data, context);
2998
+ contents = _json(data);
3060
2999
  const response = {
3061
3000
  $metadata: deserializeMetadata(output),
3062
3001
  ...contents,
3063
3002
  };
3064
- return Promise.resolve(response);
3003
+ return response;
3065
3004
  };
3066
3005
  const de_PutLoggingConfigurationCommandError = async (output, context) => {
3067
3006
  const parsedOutput = {
@@ -3084,10 +3023,9 @@ const de_PutLoggingConfigurationCommandError = async (output, context) => {
3084
3023
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3085
3024
  default:
3086
3025
  const parsedBody = parsedOutput.body;
3087
- throwDefaultError({
3026
+ return throwDefaultError({
3088
3027
  output,
3089
3028
  parsedBody,
3090
- exceptionCtor: __BaseException,
3091
3029
  errorCode,
3092
3030
  });
3093
3031
  }
@@ -3098,12 +3036,12 @@ export const de_PutPermissionPolicyCommand = async (output, context) => {
3098
3036
  }
3099
3037
  const data = await parseBody(output.body, context);
3100
3038
  let contents = {};
3101
- contents = de_PutPermissionPolicyResponse(data, context);
3039
+ contents = _json(data);
3102
3040
  const response = {
3103
3041
  $metadata: deserializeMetadata(output),
3104
3042
  ...contents,
3105
3043
  };
3106
- return Promise.resolve(response);
3044
+ return response;
3107
3045
  };
3108
3046
  const de_PutPermissionPolicyCommandError = async (output, context) => {
3109
3047
  const parsedOutput = {
@@ -3126,10 +3064,9 @@ const de_PutPermissionPolicyCommandError = async (output, context) => {
3126
3064
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3127
3065
  default:
3128
3066
  const parsedBody = parsedOutput.body;
3129
- throwDefaultError({
3067
+ return throwDefaultError({
3130
3068
  output,
3131
3069
  parsedBody,
3132
- exceptionCtor: __BaseException,
3133
3070
  errorCode,
3134
3071
  });
3135
3072
  }
@@ -3140,12 +3077,12 @@ export const de_TagResourceCommand = async (output, context) => {
3140
3077
  }
3141
3078
  const data = await parseBody(output.body, context);
3142
3079
  let contents = {};
3143
- contents = de_TagResourceResponse(data, context);
3080
+ contents = _json(data);
3144
3081
  const response = {
3145
3082
  $metadata: deserializeMetadata(output),
3146
3083
  ...contents,
3147
3084
  };
3148
- return Promise.resolve(response);
3085
+ return response;
3149
3086
  };
3150
3087
  const de_TagResourceCommandError = async (output, context) => {
3151
3088
  const parsedOutput = {
@@ -3177,10 +3114,9 @@ const de_TagResourceCommandError = async (output, context) => {
3177
3114
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
3178
3115
  default:
3179
3116
  const parsedBody = parsedOutput.body;
3180
- throwDefaultError({
3117
+ return throwDefaultError({
3181
3118
  output,
3182
3119
  parsedBody,
3183
- exceptionCtor: __BaseException,
3184
3120
  errorCode,
3185
3121
  });
3186
3122
  }
@@ -3191,12 +3127,12 @@ export const de_UntagResourceCommand = async (output, context) => {
3191
3127
  }
3192
3128
  const data = await parseBody(output.body, context);
3193
3129
  let contents = {};
3194
- contents = de_UntagResourceResponse(data, context);
3130
+ contents = _json(data);
3195
3131
  const response = {
3196
3132
  $metadata: deserializeMetadata(output),
3197
3133
  ...contents,
3198
3134
  };
3199
- return Promise.resolve(response);
3135
+ return response;
3200
3136
  };
3201
3137
  const de_UntagResourceCommandError = async (output, context) => {
3202
3138
  const parsedOutput = {
@@ -3225,10 +3161,9 @@ const de_UntagResourceCommandError = async (output, context) => {
3225
3161
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
3226
3162
  default:
3227
3163
  const parsedBody = parsedOutput.body;
3228
- throwDefaultError({
3164
+ return throwDefaultError({
3229
3165
  output,
3230
3166
  parsedBody,
3231
- exceptionCtor: __BaseException,
3232
3167
  errorCode,
3233
3168
  });
3234
3169
  }
@@ -3239,12 +3174,12 @@ export const de_UpdateByteMatchSetCommand = async (output, context) => {
3239
3174
  }
3240
3175
  const data = await parseBody(output.body, context);
3241
3176
  let contents = {};
3242
- contents = de_UpdateByteMatchSetResponse(data, context);
3177
+ contents = _json(data);
3243
3178
  const response = {
3244
3179
  $metadata: deserializeMetadata(output),
3245
3180
  ...contents,
3246
3181
  };
3247
- return Promise.resolve(response);
3182
+ return response;
3248
3183
  };
3249
3184
  const de_UpdateByteMatchSetCommandError = async (output, context) => {
3250
3185
  const parsedOutput = {
@@ -3279,10 +3214,9 @@ const de_UpdateByteMatchSetCommandError = async (output, context) => {
3279
3214
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3280
3215
  default:
3281
3216
  const parsedBody = parsedOutput.body;
3282
- throwDefaultError({
3217
+ return throwDefaultError({
3283
3218
  output,
3284
3219
  parsedBody,
3285
- exceptionCtor: __BaseException,
3286
3220
  errorCode,
3287
3221
  });
3288
3222
  }
@@ -3293,12 +3227,12 @@ export const de_UpdateGeoMatchSetCommand = async (output, context) => {
3293
3227
  }
3294
3228
  const data = await parseBody(output.body, context);
3295
3229
  let contents = {};
3296
- contents = de_UpdateGeoMatchSetResponse(data, context);
3230
+ contents = _json(data);
3297
3231
  const response = {
3298
3232
  $metadata: deserializeMetadata(output),
3299
3233
  ...contents,
3300
3234
  };
3301
- return Promise.resolve(response);
3235
+ return response;
3302
3236
  };
3303
3237
  const de_UpdateGeoMatchSetCommandError = async (output, context) => {
3304
3238
  const parsedOutput = {
@@ -3336,10 +3270,9 @@ const de_UpdateGeoMatchSetCommandError = async (output, context) => {
3336
3270
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3337
3271
  default:
3338
3272
  const parsedBody = parsedOutput.body;
3339
- throwDefaultError({
3273
+ return throwDefaultError({
3340
3274
  output,
3341
3275
  parsedBody,
3342
- exceptionCtor: __BaseException,
3343
3276
  errorCode,
3344
3277
  });
3345
3278
  }
@@ -3350,12 +3283,12 @@ export const de_UpdateIPSetCommand = async (output, context) => {
3350
3283
  }
3351
3284
  const data = await parseBody(output.body, context);
3352
3285
  let contents = {};
3353
- contents = de_UpdateIPSetResponse(data, context);
3286
+ contents = _json(data);
3354
3287
  const response = {
3355
3288
  $metadata: deserializeMetadata(output),
3356
3289
  ...contents,
3357
3290
  };
3358
- return Promise.resolve(response);
3291
+ return response;
3359
3292
  };
3360
3293
  const de_UpdateIPSetCommandError = async (output, context) => {
3361
3294
  const parsedOutput = {
@@ -3393,10 +3326,9 @@ const de_UpdateIPSetCommandError = async (output, context) => {
3393
3326
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3394
3327
  default:
3395
3328
  const parsedBody = parsedOutput.body;
3396
- throwDefaultError({
3329
+ return throwDefaultError({
3397
3330
  output,
3398
3331
  parsedBody,
3399
- exceptionCtor: __BaseException,
3400
3332
  errorCode,
3401
3333
  });
3402
3334
  }
@@ -3407,12 +3339,12 @@ export const de_UpdateRateBasedRuleCommand = async (output, context) => {
3407
3339
  }
3408
3340
  const data = await parseBody(output.body, context);
3409
3341
  let contents = {};
3410
- contents = de_UpdateRateBasedRuleResponse(data, context);
3342
+ contents = _json(data);
3411
3343
  const response = {
3412
3344
  $metadata: deserializeMetadata(output),
3413
3345
  ...contents,
3414
3346
  };
3415
- return Promise.resolve(response);
3347
+ return response;
3416
3348
  };
3417
3349
  const de_UpdateRateBasedRuleCommandError = async (output, context) => {
3418
3350
  const parsedOutput = {
@@ -3450,10 +3382,9 @@ const de_UpdateRateBasedRuleCommandError = async (output, context) => {
3450
3382
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3451
3383
  default:
3452
3384
  const parsedBody = parsedOutput.body;
3453
- throwDefaultError({
3385
+ return throwDefaultError({
3454
3386
  output,
3455
3387
  parsedBody,
3456
- exceptionCtor: __BaseException,
3457
3388
  errorCode,
3458
3389
  });
3459
3390
  }
@@ -3464,12 +3395,12 @@ export const de_UpdateRegexMatchSetCommand = async (output, context) => {
3464
3395
  }
3465
3396
  const data = await parseBody(output.body, context);
3466
3397
  let contents = {};
3467
- contents = de_UpdateRegexMatchSetResponse(data, context);
3398
+ contents = _json(data);
3468
3399
  const response = {
3469
3400
  $metadata: deserializeMetadata(output),
3470
3401
  ...contents,
3471
3402
  };
3472
- return Promise.resolve(response);
3403
+ return response;
3473
3404
  };
3474
3405
  const de_UpdateRegexMatchSetCommandError = async (output, context) => {
3475
3406
  const parsedOutput = {
@@ -3504,10 +3435,9 @@ const de_UpdateRegexMatchSetCommandError = async (output, context) => {
3504
3435
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3505
3436
  default:
3506
3437
  const parsedBody = parsedOutput.body;
3507
- throwDefaultError({
3438
+ return throwDefaultError({
3508
3439
  output,
3509
3440
  parsedBody,
3510
- exceptionCtor: __BaseException,
3511
3441
  errorCode,
3512
3442
  });
3513
3443
  }
@@ -3518,12 +3448,12 @@ export const de_UpdateRegexPatternSetCommand = async (output, context) => {
3518
3448
  }
3519
3449
  const data = await parseBody(output.body, context);
3520
3450
  let contents = {};
3521
- contents = de_UpdateRegexPatternSetResponse(data, context);
3451
+ contents = _json(data);
3522
3452
  const response = {
3523
3453
  $metadata: deserializeMetadata(output),
3524
3454
  ...contents,
3525
3455
  };
3526
- return Promise.resolve(response);
3456
+ return response;
3527
3457
  };
3528
3458
  const de_UpdateRegexPatternSetCommandError = async (output, context) => {
3529
3459
  const parsedOutput = {
@@ -3558,10 +3488,9 @@ const de_UpdateRegexPatternSetCommandError = async (output, context) => {
3558
3488
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3559
3489
  default:
3560
3490
  const parsedBody = parsedOutput.body;
3561
- throwDefaultError({
3491
+ return throwDefaultError({
3562
3492
  output,
3563
3493
  parsedBody,
3564
- exceptionCtor: __BaseException,
3565
3494
  errorCode,
3566
3495
  });
3567
3496
  }
@@ -3572,12 +3501,12 @@ export const de_UpdateRuleCommand = async (output, context) => {
3572
3501
  }
3573
3502
  const data = await parseBody(output.body, context);
3574
3503
  let contents = {};
3575
- contents = de_UpdateRuleResponse(data, context);
3504
+ contents = _json(data);
3576
3505
  const response = {
3577
3506
  $metadata: deserializeMetadata(output),
3578
3507
  ...contents,
3579
3508
  };
3580
- return Promise.resolve(response);
3509
+ return response;
3581
3510
  };
3582
3511
  const de_UpdateRuleCommandError = async (output, context) => {
3583
3512
  const parsedOutput = {
@@ -3615,10 +3544,9 @@ const de_UpdateRuleCommandError = async (output, context) => {
3615
3544
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3616
3545
  default:
3617
3546
  const parsedBody = parsedOutput.body;
3618
- throwDefaultError({
3547
+ return throwDefaultError({
3619
3548
  output,
3620
3549
  parsedBody,
3621
- exceptionCtor: __BaseException,
3622
3550
  errorCode,
3623
3551
  });
3624
3552
  }
@@ -3629,12 +3557,12 @@ export const de_UpdateRuleGroupCommand = async (output, context) => {
3629
3557
  }
3630
3558
  const data = await parseBody(output.body, context);
3631
3559
  let contents = {};
3632
- contents = de_UpdateRuleGroupResponse(data, context);
3560
+ contents = _json(data);
3633
3561
  const response = {
3634
3562
  $metadata: deserializeMetadata(output),
3635
3563
  ...contents,
3636
3564
  };
3637
- return Promise.resolve(response);
3565
+ return response;
3638
3566
  };
3639
3567
  const de_UpdateRuleGroupCommandError = async (output, context) => {
3640
3568
  const parsedOutput = {
@@ -3666,10 +3594,9 @@ const de_UpdateRuleGroupCommandError = async (output, context) => {
3666
3594
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3667
3595
  default:
3668
3596
  const parsedBody = parsedOutput.body;
3669
- throwDefaultError({
3597
+ return throwDefaultError({
3670
3598
  output,
3671
3599
  parsedBody,
3672
- exceptionCtor: __BaseException,
3673
3600
  errorCode,
3674
3601
  });
3675
3602
  }
@@ -3680,12 +3607,12 @@ export const de_UpdateSizeConstraintSetCommand = async (output, context) => {
3680
3607
  }
3681
3608
  const data = await parseBody(output.body, context);
3682
3609
  let contents = {};
3683
- contents = de_UpdateSizeConstraintSetResponse(data, context);
3610
+ contents = _json(data);
3684
3611
  const response = {
3685
3612
  $metadata: deserializeMetadata(output),
3686
3613
  ...contents,
3687
3614
  };
3688
- return Promise.resolve(response);
3615
+ return response;
3689
3616
  };
3690
3617
  const de_UpdateSizeConstraintSetCommandError = async (output, context) => {
3691
3618
  const parsedOutput = {
@@ -3723,10 +3650,9 @@ const de_UpdateSizeConstraintSetCommandError = async (output, context) => {
3723
3650
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3724
3651
  default:
3725
3652
  const parsedBody = parsedOutput.body;
3726
- throwDefaultError({
3653
+ return throwDefaultError({
3727
3654
  output,
3728
3655
  parsedBody,
3729
- exceptionCtor: __BaseException,
3730
3656
  errorCode,
3731
3657
  });
3732
3658
  }
@@ -3737,12 +3663,12 @@ export const de_UpdateSqlInjectionMatchSetCommand = async (output, context) => {
3737
3663
  }
3738
3664
  const data = await parseBody(output.body, context);
3739
3665
  let contents = {};
3740
- contents = de_UpdateSqlInjectionMatchSetResponse(data, context);
3666
+ contents = _json(data);
3741
3667
  const response = {
3742
3668
  $metadata: deserializeMetadata(output),
3743
3669
  ...contents,
3744
3670
  };
3745
- return Promise.resolve(response);
3671
+ return response;
3746
3672
  };
3747
3673
  const de_UpdateSqlInjectionMatchSetCommandError = async (output, context) => {
3748
3674
  const parsedOutput = {
@@ -3777,10 +3703,9 @@ const de_UpdateSqlInjectionMatchSetCommandError = async (output, context) => {
3777
3703
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3778
3704
  default:
3779
3705
  const parsedBody = parsedOutput.body;
3780
- throwDefaultError({
3706
+ return throwDefaultError({
3781
3707
  output,
3782
3708
  parsedBody,
3783
- exceptionCtor: __BaseException,
3784
3709
  errorCode,
3785
3710
  });
3786
3711
  }
@@ -3791,12 +3716,12 @@ export const de_UpdateWebACLCommand = async (output, context) => {
3791
3716
  }
3792
3717
  const data = await parseBody(output.body, context);
3793
3718
  let contents = {};
3794
- contents = de_UpdateWebACLResponse(data, context);
3719
+ contents = _json(data);
3795
3720
  const response = {
3796
3721
  $metadata: deserializeMetadata(output),
3797
3722
  ...contents,
3798
3723
  };
3799
- return Promise.resolve(response);
3724
+ return response;
3800
3725
  };
3801
3726
  const de_UpdateWebACLCommandError = async (output, context) => {
3802
3727
  const parsedOutput = {
@@ -3837,10 +3762,9 @@ const de_UpdateWebACLCommandError = async (output, context) => {
3837
3762
  throw await de_WAFSubscriptionNotFoundExceptionRes(parsedOutput, context);
3838
3763
  default:
3839
3764
  const parsedBody = parsedOutput.body;
3840
- throwDefaultError({
3765
+ return throwDefaultError({
3841
3766
  output,
3842
3767
  parsedBody,
3843
- exceptionCtor: __BaseException,
3844
3768
  errorCode,
3845
3769
  });
3846
3770
  }
@@ -3851,12 +3775,12 @@ export const de_UpdateXssMatchSetCommand = async (output, context) => {
3851
3775
  }
3852
3776
  const data = await parseBody(output.body, context);
3853
3777
  let contents = {};
3854
- contents = de_UpdateXssMatchSetResponse(data, context);
3778
+ contents = _json(data);
3855
3779
  const response = {
3856
3780
  $metadata: deserializeMetadata(output),
3857
3781
  ...contents,
3858
3782
  };
3859
- return Promise.resolve(response);
3783
+ return response;
3860
3784
  };
3861
3785
  const de_UpdateXssMatchSetCommandError = async (output, context) => {
3862
3786
  const parsedOutput = {
@@ -3891,17 +3815,16 @@ const de_UpdateXssMatchSetCommandError = async (output, context) => {
3891
3815
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3892
3816
  default:
3893
3817
  const parsedBody = parsedOutput.body;
3894
- throwDefaultError({
3818
+ return throwDefaultError({
3895
3819
  output,
3896
3820
  parsedBody,
3897
- exceptionCtor: __BaseException,
3898
3821
  errorCode,
3899
3822
  });
3900
3823
  }
3901
3824
  };
3902
3825
  const de_WAFBadRequestExceptionRes = async (parsedOutput, context) => {
3903
3826
  const body = parsedOutput.body;
3904
- const deserialized = de_WAFBadRequestException(body, context);
3827
+ const deserialized = _json(body);
3905
3828
  const exception = new WAFBadRequestException({
3906
3829
  $metadata: deserializeMetadata(parsedOutput),
3907
3830
  ...deserialized,
@@ -3910,7 +3833,7 @@ const de_WAFBadRequestExceptionRes = async (parsedOutput, context) => {
3910
3833
  };
3911
3834
  const de_WAFDisallowedNameExceptionRes = async (parsedOutput, context) => {
3912
3835
  const body = parsedOutput.body;
3913
- const deserialized = de_WAFDisallowedNameException(body, context);
3836
+ const deserialized = _json(body);
3914
3837
  const exception = new WAFDisallowedNameException({
3915
3838
  $metadata: deserializeMetadata(parsedOutput),
3916
3839
  ...deserialized,
@@ -3919,7 +3842,7 @@ const de_WAFDisallowedNameExceptionRes = async (parsedOutput, context) => {
3919
3842
  };
3920
3843
  const de_WAFEntityMigrationExceptionRes = async (parsedOutput, context) => {
3921
3844
  const body = parsedOutput.body;
3922
- const deserialized = de_WAFEntityMigrationException(body, context);
3845
+ const deserialized = _json(body);
3923
3846
  const exception = new WAFEntityMigrationException({
3924
3847
  $metadata: deserializeMetadata(parsedOutput),
3925
3848
  ...deserialized,
@@ -3928,7 +3851,7 @@ const de_WAFEntityMigrationExceptionRes = async (parsedOutput, context) => {
3928
3851
  };
3929
3852
  const de_WAFInternalErrorExceptionRes = async (parsedOutput, context) => {
3930
3853
  const body = parsedOutput.body;
3931
- const deserialized = de_WAFInternalErrorException(body, context);
3854
+ const deserialized = _json(body);
3932
3855
  const exception = new WAFInternalErrorException({
3933
3856
  $metadata: deserializeMetadata(parsedOutput),
3934
3857
  ...deserialized,
@@ -3937,7 +3860,7 @@ const de_WAFInternalErrorExceptionRes = async (parsedOutput, context) => {
3937
3860
  };
3938
3861
  const de_WAFInvalidAccountExceptionRes = async (parsedOutput, context) => {
3939
3862
  const body = parsedOutput.body;
3940
- const deserialized = de_WAFInvalidAccountException(body, context);
3863
+ const deserialized = _json(body);
3941
3864
  const exception = new WAFInvalidAccountException({
3942
3865
  $metadata: deserializeMetadata(parsedOutput),
3943
3866
  ...deserialized,
@@ -3946,7 +3869,7 @@ const de_WAFInvalidAccountExceptionRes = async (parsedOutput, context) => {
3946
3869
  };
3947
3870
  const de_WAFInvalidOperationExceptionRes = async (parsedOutput, context) => {
3948
3871
  const body = parsedOutput.body;
3949
- const deserialized = de_WAFInvalidOperationException(body, context);
3872
+ const deserialized = _json(body);
3950
3873
  const exception = new WAFInvalidOperationException({
3951
3874
  $metadata: deserializeMetadata(parsedOutput),
3952
3875
  ...deserialized,
@@ -3955,7 +3878,7 @@ const de_WAFInvalidOperationExceptionRes = async (parsedOutput, context) => {
3955
3878
  };
3956
3879
  const de_WAFInvalidParameterExceptionRes = async (parsedOutput, context) => {
3957
3880
  const body = parsedOutput.body;
3958
- const deserialized = de_WAFInvalidParameterException(body, context);
3881
+ const deserialized = _json(body);
3959
3882
  const exception = new WAFInvalidParameterException({
3960
3883
  $metadata: deserializeMetadata(parsedOutput),
3961
3884
  ...deserialized,
@@ -3964,7 +3887,7 @@ const de_WAFInvalidParameterExceptionRes = async (parsedOutput, context) => {
3964
3887
  };
3965
3888
  const de_WAFInvalidPermissionPolicyExceptionRes = async (parsedOutput, context) => {
3966
3889
  const body = parsedOutput.body;
3967
- const deserialized = de_WAFInvalidPermissionPolicyException(body, context);
3890
+ const deserialized = _json(body);
3968
3891
  const exception = new WAFInvalidPermissionPolicyException({
3969
3892
  $metadata: deserializeMetadata(parsedOutput),
3970
3893
  ...deserialized,
@@ -3973,7 +3896,7 @@ const de_WAFInvalidPermissionPolicyExceptionRes = async (parsedOutput, context)
3973
3896
  };
3974
3897
  const de_WAFInvalidRegexPatternExceptionRes = async (parsedOutput, context) => {
3975
3898
  const body = parsedOutput.body;
3976
- const deserialized = de_WAFInvalidRegexPatternException(body, context);
3899
+ const deserialized = _json(body);
3977
3900
  const exception = new WAFInvalidRegexPatternException({
3978
3901
  $metadata: deserializeMetadata(parsedOutput),
3979
3902
  ...deserialized,
@@ -3982,7 +3905,7 @@ const de_WAFInvalidRegexPatternExceptionRes = async (parsedOutput, context) => {
3982
3905
  };
3983
3906
  const de_WAFLimitsExceededExceptionRes = async (parsedOutput, context) => {
3984
3907
  const body = parsedOutput.body;
3985
- const deserialized = de_WAFLimitsExceededException(body, context);
3908
+ const deserialized = _json(body);
3986
3909
  const exception = new WAFLimitsExceededException({
3987
3910
  $metadata: deserializeMetadata(parsedOutput),
3988
3911
  ...deserialized,
@@ -3991,7 +3914,7 @@ const de_WAFLimitsExceededExceptionRes = async (parsedOutput, context) => {
3991
3914
  };
3992
3915
  const de_WAFNonEmptyEntityExceptionRes = async (parsedOutput, context) => {
3993
3916
  const body = parsedOutput.body;
3994
- const deserialized = de_WAFNonEmptyEntityException(body, context);
3917
+ const deserialized = _json(body);
3995
3918
  const exception = new WAFNonEmptyEntityException({
3996
3919
  $metadata: deserializeMetadata(parsedOutput),
3997
3920
  ...deserialized,
@@ -4000,7 +3923,7 @@ const de_WAFNonEmptyEntityExceptionRes = async (parsedOutput, context) => {
4000
3923
  };
4001
3924
  const de_WAFNonexistentContainerExceptionRes = async (parsedOutput, context) => {
4002
3925
  const body = parsedOutput.body;
4003
- const deserialized = de_WAFNonexistentContainerException(body, context);
3926
+ const deserialized = _json(body);
4004
3927
  const exception = new WAFNonexistentContainerException({
4005
3928
  $metadata: deserializeMetadata(parsedOutput),
4006
3929
  ...deserialized,
@@ -4009,7 +3932,7 @@ const de_WAFNonexistentContainerExceptionRes = async (parsedOutput, context) =>
4009
3932
  };
4010
3933
  const de_WAFNonexistentItemExceptionRes = async (parsedOutput, context) => {
4011
3934
  const body = parsedOutput.body;
4012
- const deserialized = de_WAFNonexistentItemException(body, context);
3935
+ const deserialized = _json(body);
4013
3936
  const exception = new WAFNonexistentItemException({
4014
3937
  $metadata: deserializeMetadata(parsedOutput),
4015
3938
  ...deserialized,
@@ -4018,7 +3941,7 @@ const de_WAFNonexistentItemExceptionRes = async (parsedOutput, context) => {
4018
3941
  };
4019
3942
  const de_WAFReferencedItemExceptionRes = async (parsedOutput, context) => {
4020
3943
  const body = parsedOutput.body;
4021
- const deserialized = de_WAFReferencedItemException(body, context);
3944
+ const deserialized = _json(body);
4022
3945
  const exception = new WAFReferencedItemException({
4023
3946
  $metadata: deserializeMetadata(parsedOutput),
4024
3947
  ...deserialized,
@@ -4027,7 +3950,7 @@ const de_WAFReferencedItemExceptionRes = async (parsedOutput, context) => {
4027
3950
  };
4028
3951
  const de_WAFServiceLinkedRoleErrorExceptionRes = async (parsedOutput, context) => {
4029
3952
  const body = parsedOutput.body;
4030
- const deserialized = de_WAFServiceLinkedRoleErrorException(body, context);
3953
+ const deserialized = _json(body);
4031
3954
  const exception = new WAFServiceLinkedRoleErrorException({
4032
3955
  $metadata: deserializeMetadata(parsedOutput),
4033
3956
  ...deserialized,
@@ -4036,7 +3959,7 @@ const de_WAFServiceLinkedRoleErrorExceptionRes = async (parsedOutput, context) =
4036
3959
  };
4037
3960
  const de_WAFStaleDataExceptionRes = async (parsedOutput, context) => {
4038
3961
  const body = parsedOutput.body;
4039
- const deserialized = de_WAFStaleDataException(body, context);
3962
+ const deserialized = _json(body);
4040
3963
  const exception = new WAFStaleDataException({
4041
3964
  $metadata: deserializeMetadata(parsedOutput),
4042
3965
  ...deserialized,
@@ -4045,7 +3968,7 @@ const de_WAFStaleDataExceptionRes = async (parsedOutput, context) => {
4045
3968
  };
4046
3969
  const de_WAFSubscriptionNotFoundExceptionRes = async (parsedOutput, context) => {
4047
3970
  const body = parsedOutput.body;
4048
- const deserialized = de_WAFSubscriptionNotFoundException(body, context);
3971
+ const deserialized = _json(body);
4049
3972
  const exception = new WAFSubscriptionNotFoundException({
4050
3973
  $metadata: deserializeMetadata(parsedOutput),
4051
3974
  ...deserialized,
@@ -4054,7 +3977,7 @@ const de_WAFSubscriptionNotFoundExceptionRes = async (parsedOutput, context) =>
4054
3977
  };
4055
3978
  const de_WAFTagOperationExceptionRes = async (parsedOutput, context) => {
4056
3979
  const body = parsedOutput.body;
4057
- const deserialized = de_WAFTagOperationException(body, context);
3980
+ const deserialized = _json(body);
4058
3981
  const exception = new WAFTagOperationException({
4059
3982
  $metadata: deserializeMetadata(parsedOutput),
4060
3983
  ...deserialized,
@@ -4063,1913 +3986,118 @@ const de_WAFTagOperationExceptionRes = async (parsedOutput, context) => {
4063
3986
  };
4064
3987
  const de_WAFTagOperationInternalErrorExceptionRes = async (parsedOutput, context) => {
4065
3988
  const body = parsedOutput.body;
4066
- const deserialized = de_WAFTagOperationInternalErrorException(body, context);
3989
+ const deserialized = _json(body);
4067
3990
  const exception = new WAFTagOperationInternalErrorException({
4068
3991
  $metadata: deserializeMetadata(parsedOutput),
4069
3992
  ...deserialized,
4070
3993
  });
4071
3994
  return __decorateServiceException(exception, body);
4072
3995
  };
4073
- const se_ActivatedRule = (input, context) => {
4074
- return {
4075
- ...(input.Action != null && { Action: se_WafAction(input.Action, context) }),
4076
- ...(input.ExcludedRules != null && { ExcludedRules: se_ExcludedRules(input.ExcludedRules, context) }),
4077
- ...(input.OverrideAction != null && { OverrideAction: se_WafOverrideAction(input.OverrideAction, context) }),
4078
- ...(input.Priority != null && { Priority: input.Priority }),
4079
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4080
- ...(input.Type != null && { Type: input.Type }),
4081
- };
4082
- };
4083
- const se_ByteMatchSetUpdate = (input, context) => {
4084
- return {
4085
- ...(input.Action != null && { Action: input.Action }),
4086
- ...(input.ByteMatchTuple != null && { ByteMatchTuple: se_ByteMatchTuple(input.ByteMatchTuple, context) }),
4087
- };
4088
- };
4089
- const se_ByteMatchSetUpdates = (input, context) => {
4090
- return input
4091
- .filter((e) => e != null)
4092
- .map((entry) => {
4093
- return se_ByteMatchSetUpdate(entry, context);
4094
- });
4095
- };
4096
- const se_ByteMatchTuple = (input, context) => {
4097
- return {
4098
- ...(input.FieldToMatch != null && { FieldToMatch: se_FieldToMatch(input.FieldToMatch, context) }),
4099
- ...(input.PositionalConstraint != null && { PositionalConstraint: input.PositionalConstraint }),
4100
- ...(input.TargetString != null && { TargetString: context.base64Encoder(input.TargetString) }),
4101
- ...(input.TextTransformation != null && { TextTransformation: input.TextTransformation }),
4102
- };
4103
- };
4104
- const se_CreateByteMatchSetRequest = (input, context) => {
4105
- return {
4106
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4107
- ...(input.Name != null && { Name: input.Name }),
4108
- };
4109
- };
4110
- const se_CreateGeoMatchSetRequest = (input, context) => {
4111
- return {
4112
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4113
- ...(input.Name != null && { Name: input.Name }),
4114
- };
4115
- };
4116
- const se_CreateIPSetRequest = (input, context) => {
4117
- return {
4118
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4119
- ...(input.Name != null && { Name: input.Name }),
4120
- };
4121
- };
4122
- const se_CreateRateBasedRuleRequest = (input, context) => {
4123
- return {
4124
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4125
- ...(input.MetricName != null && { MetricName: input.MetricName }),
4126
- ...(input.Name != null && { Name: input.Name }),
4127
- ...(input.RateKey != null && { RateKey: input.RateKey }),
4128
- ...(input.RateLimit != null && { RateLimit: input.RateLimit }),
4129
- ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
4130
- };
4131
- };
4132
- const se_CreateRegexMatchSetRequest = (input, context) => {
4133
- return {
4134
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4135
- ...(input.Name != null && { Name: input.Name }),
4136
- };
4137
- };
4138
- const se_CreateRegexPatternSetRequest = (input, context) => {
4139
- return {
4140
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4141
- ...(input.Name != null && { Name: input.Name }),
4142
- };
4143
- };
4144
- const se_CreateRuleGroupRequest = (input, context) => {
4145
- return {
4146
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4147
- ...(input.MetricName != null && { MetricName: input.MetricName }),
4148
- ...(input.Name != null && { Name: input.Name }),
4149
- ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
4150
- };
4151
- };
4152
- const se_CreateRuleRequest = (input, context) => {
4153
- return {
4154
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4155
- ...(input.MetricName != null && { MetricName: input.MetricName }),
4156
- ...(input.Name != null && { Name: input.Name }),
4157
- ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
4158
- };
4159
- };
4160
- const se_CreateSizeConstraintSetRequest = (input, context) => {
4161
- return {
4162
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4163
- ...(input.Name != null && { Name: input.Name }),
4164
- };
4165
- };
4166
- const se_CreateSqlInjectionMatchSetRequest = (input, context) => {
4167
- return {
4168
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4169
- ...(input.Name != null && { Name: input.Name }),
4170
- };
4171
- };
4172
- const se_CreateWebACLMigrationStackRequest = (input, context) => {
4173
- return {
4174
- ...(input.IgnoreUnsupportedType != null && { IgnoreUnsupportedType: input.IgnoreUnsupportedType }),
4175
- ...(input.S3BucketName != null && { S3BucketName: input.S3BucketName }),
4176
- ...(input.WebACLId != null && { WebACLId: input.WebACLId }),
4177
- };
4178
- };
4179
- const se_CreateWebACLRequest = (input, context) => {
4180
- return {
4181
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4182
- ...(input.DefaultAction != null && { DefaultAction: se_WafAction(input.DefaultAction, context) }),
4183
- ...(input.MetricName != null && { MetricName: input.MetricName }),
4184
- ...(input.Name != null && { Name: input.Name }),
4185
- ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
4186
- };
4187
- };
4188
- const se_CreateXssMatchSetRequest = (input, context) => {
4189
- return {
4190
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4191
- ...(input.Name != null && { Name: input.Name }),
4192
- };
4193
- };
4194
- const se_DeleteByteMatchSetRequest = (input, context) => {
4195
- return {
4196
- ...(input.ByteMatchSetId != null && { ByteMatchSetId: input.ByteMatchSetId }),
4197
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4198
- };
4199
- };
4200
- const se_DeleteGeoMatchSetRequest = (input, context) => {
4201
- return {
4202
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4203
- ...(input.GeoMatchSetId != null && { GeoMatchSetId: input.GeoMatchSetId }),
4204
- };
4205
- };
4206
- const se_DeleteIPSetRequest = (input, context) => {
4207
- return {
4208
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4209
- ...(input.IPSetId != null && { IPSetId: input.IPSetId }),
4210
- };
4211
- };
4212
- const se_DeleteLoggingConfigurationRequest = (input, context) => {
4213
- return {
4214
- ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
4215
- };
4216
- };
4217
- const se_DeletePermissionPolicyRequest = (input, context) => {
4218
- return {
4219
- ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
4220
- };
4221
- };
4222
- const se_DeleteRateBasedRuleRequest = (input, context) => {
4223
- return {
4224
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4225
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4226
- };
4227
- };
4228
- const se_DeleteRegexMatchSetRequest = (input, context) => {
4229
- return {
4230
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4231
- ...(input.RegexMatchSetId != null && { RegexMatchSetId: input.RegexMatchSetId }),
4232
- };
4233
- };
4234
- const se_DeleteRegexPatternSetRequest = (input, context) => {
4235
- return {
4236
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4237
- ...(input.RegexPatternSetId != null && { RegexPatternSetId: input.RegexPatternSetId }),
4238
- };
4239
- };
4240
- const se_DeleteRuleGroupRequest = (input, context) => {
4241
- return {
4242
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4243
- ...(input.RuleGroupId != null && { RuleGroupId: input.RuleGroupId }),
4244
- };
4245
- };
4246
- const se_DeleteRuleRequest = (input, context) => {
4247
- return {
4248
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4249
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4250
- };
4251
- };
4252
- const se_DeleteSizeConstraintSetRequest = (input, context) => {
4253
- return {
4254
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4255
- ...(input.SizeConstraintSetId != null && { SizeConstraintSetId: input.SizeConstraintSetId }),
4256
- };
4257
- };
4258
- const se_DeleteSqlInjectionMatchSetRequest = (input, context) => {
4259
- return {
4260
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4261
- ...(input.SqlInjectionMatchSetId != null && { SqlInjectionMatchSetId: input.SqlInjectionMatchSetId }),
4262
- };
4263
- };
4264
- const se_DeleteWebACLRequest = (input, context) => {
4265
- return {
4266
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4267
- ...(input.WebACLId != null && { WebACLId: input.WebACLId }),
4268
- };
4269
- };
4270
- const se_DeleteXssMatchSetRequest = (input, context) => {
4271
- return {
4272
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4273
- ...(input.XssMatchSetId != null && { XssMatchSetId: input.XssMatchSetId }),
4274
- };
4275
- };
4276
- const se_ExcludedRule = (input, context) => {
4277
- return {
4278
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4279
- };
4280
- };
4281
- const se_ExcludedRules = (input, context) => {
4282
- return input
4283
- .filter((e) => e != null)
4284
- .map((entry) => {
4285
- return se_ExcludedRule(entry, context);
4286
- });
4287
- };
4288
- const se_FieldToMatch = (input, context) => {
4289
- return {
4290
- ...(input.Data != null && { Data: input.Data }),
4291
- ...(input.Type != null && { Type: input.Type }),
4292
- };
4293
- };
4294
- const se_GeoMatchConstraint = (input, context) => {
4295
- return {
4296
- ...(input.Type != null && { Type: input.Type }),
4297
- ...(input.Value != null && { Value: input.Value }),
4298
- };
4299
- };
4300
- const se_GeoMatchSetUpdate = (input, context) => {
4301
- return {
4302
- ...(input.Action != null && { Action: input.Action }),
4303
- ...(input.GeoMatchConstraint != null && {
4304
- GeoMatchConstraint: se_GeoMatchConstraint(input.GeoMatchConstraint, context),
4305
- }),
4306
- };
4307
- };
4308
- const se_GeoMatchSetUpdates = (input, context) => {
4309
- return input
4310
- .filter((e) => e != null)
4311
- .map((entry) => {
4312
- return se_GeoMatchSetUpdate(entry, context);
4313
- });
4314
- };
4315
- const se_GetByteMatchSetRequest = (input, context) => {
4316
- return {
4317
- ...(input.ByteMatchSetId != null && { ByteMatchSetId: input.ByteMatchSetId }),
4318
- };
4319
- };
4320
- const se_GetChangeTokenRequest = (input, context) => {
4321
- return {};
4322
- };
4323
- const se_GetChangeTokenStatusRequest = (input, context) => {
4324
- return {
4325
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4326
- };
4327
- };
4328
- const se_GetGeoMatchSetRequest = (input, context) => {
4329
- return {
4330
- ...(input.GeoMatchSetId != null && { GeoMatchSetId: input.GeoMatchSetId }),
4331
- };
4332
- };
4333
- const se_GetIPSetRequest = (input, context) => {
4334
- return {
4335
- ...(input.IPSetId != null && { IPSetId: input.IPSetId }),
4336
- };
4337
- };
4338
- const se_GetLoggingConfigurationRequest = (input, context) => {
4339
- return {
4340
- ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
4341
- };
4342
- };
4343
- const se_GetPermissionPolicyRequest = (input, context) => {
4344
- return {
4345
- ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
4346
- };
4347
- };
4348
- const se_GetRateBasedRuleManagedKeysRequest = (input, context) => {
4349
- return {
4350
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4351
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4352
- };
4353
- };
4354
- const se_GetRateBasedRuleRequest = (input, context) => {
4355
- return {
4356
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4357
- };
4358
- };
4359
- const se_GetRegexMatchSetRequest = (input, context) => {
4360
- return {
4361
- ...(input.RegexMatchSetId != null && { RegexMatchSetId: input.RegexMatchSetId }),
4362
- };
4363
- };
4364
- const se_GetRegexPatternSetRequest = (input, context) => {
4365
- return {
4366
- ...(input.RegexPatternSetId != null && { RegexPatternSetId: input.RegexPatternSetId }),
4367
- };
4368
- };
4369
- const se_GetRuleGroupRequest = (input, context) => {
4370
- return {
4371
- ...(input.RuleGroupId != null && { RuleGroupId: input.RuleGroupId }),
4372
- };
4373
- };
4374
- const se_GetRuleRequest = (input, context) => {
4375
- return {
4376
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4377
- };
4378
- };
4379
- const se_GetSampledRequestsRequest = (input, context) => {
4380
- return {
4381
- ...(input.MaxItems != null && { MaxItems: input.MaxItems }),
4382
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4383
- ...(input.TimeWindow != null && { TimeWindow: se_TimeWindow(input.TimeWindow, context) }),
4384
- ...(input.WebAclId != null && { WebAclId: input.WebAclId }),
4385
- };
4386
- };
4387
- const se_GetSizeConstraintSetRequest = (input, context) => {
4388
- return {
4389
- ...(input.SizeConstraintSetId != null && { SizeConstraintSetId: input.SizeConstraintSetId }),
4390
- };
4391
- };
4392
- const se_GetSqlInjectionMatchSetRequest = (input, context) => {
4393
- return {
4394
- ...(input.SqlInjectionMatchSetId != null && { SqlInjectionMatchSetId: input.SqlInjectionMatchSetId }),
4395
- };
4396
- };
4397
- const se_GetWebACLRequest = (input, context) => {
4398
- return {
4399
- ...(input.WebACLId != null && { WebACLId: input.WebACLId }),
4400
- };
4401
- };
4402
- const se_GetXssMatchSetRequest = (input, context) => {
4403
- return {
4404
- ...(input.XssMatchSetId != null && { XssMatchSetId: input.XssMatchSetId }),
4405
- };
4406
- };
4407
- const se_IPSetDescriptor = (input, context) => {
4408
- return {
4409
- ...(input.Type != null && { Type: input.Type }),
4410
- ...(input.Value != null && { Value: input.Value }),
4411
- };
4412
- };
4413
- const se_IPSetUpdate = (input, context) => {
4414
- return {
4415
- ...(input.Action != null && { Action: input.Action }),
4416
- ...(input.IPSetDescriptor != null && { IPSetDescriptor: se_IPSetDescriptor(input.IPSetDescriptor, context) }),
4417
- };
4418
- };
4419
- const se_IPSetUpdates = (input, context) => {
4420
- return input
4421
- .filter((e) => e != null)
4422
- .map((entry) => {
4423
- return se_IPSetUpdate(entry, context);
4424
- });
4425
- };
4426
- const se_ListActivatedRulesInRuleGroupRequest = (input, context) => {
4427
- return {
4428
- ...(input.Limit != null && { Limit: input.Limit }),
4429
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4430
- ...(input.RuleGroupId != null && { RuleGroupId: input.RuleGroupId }),
4431
- };
4432
- };
4433
- const se_ListByteMatchSetsRequest = (input, context) => {
4434
- return {
4435
- ...(input.Limit != null && { Limit: input.Limit }),
4436
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4437
- };
4438
- };
4439
- const se_ListGeoMatchSetsRequest = (input, context) => {
4440
- return {
4441
- ...(input.Limit != null && { Limit: input.Limit }),
4442
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4443
- };
4444
- };
4445
- const se_ListIPSetsRequest = (input, context) => {
4446
- return {
4447
- ...(input.Limit != null && { Limit: input.Limit }),
4448
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4449
- };
4450
- };
4451
- const se_ListLoggingConfigurationsRequest = (input, context) => {
4452
- return {
4453
- ...(input.Limit != null && { Limit: input.Limit }),
4454
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4455
- };
4456
- };
4457
- const se_ListRateBasedRulesRequest = (input, context) => {
4458
- return {
4459
- ...(input.Limit != null && { Limit: input.Limit }),
4460
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4461
- };
4462
- };
4463
- const se_ListRegexMatchSetsRequest = (input, context) => {
4464
- return {
4465
- ...(input.Limit != null && { Limit: input.Limit }),
4466
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4467
- };
4468
- };
4469
- const se_ListRegexPatternSetsRequest = (input, context) => {
4470
- return {
4471
- ...(input.Limit != null && { Limit: input.Limit }),
4472
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4473
- };
4474
- };
4475
- const se_ListRuleGroupsRequest = (input, context) => {
4476
- return {
4477
- ...(input.Limit != null && { Limit: input.Limit }),
4478
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4479
- };
4480
- };
4481
- const se_ListRulesRequest = (input, context) => {
4482
- return {
4483
- ...(input.Limit != null && { Limit: input.Limit }),
4484
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4485
- };
4486
- };
4487
- const se_ListSizeConstraintSetsRequest = (input, context) => {
4488
- return {
4489
- ...(input.Limit != null && { Limit: input.Limit }),
4490
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4491
- };
4492
- };
4493
- const se_ListSqlInjectionMatchSetsRequest = (input, context) => {
4494
- return {
4495
- ...(input.Limit != null && { Limit: input.Limit }),
4496
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4497
- };
4498
- };
4499
- const se_ListSubscribedRuleGroupsRequest = (input, context) => {
4500
- return {
4501
- ...(input.Limit != null && { Limit: input.Limit }),
4502
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4503
- };
4504
- };
4505
- const se_ListTagsForResourceRequest = (input, context) => {
4506
- return {
4507
- ...(input.Limit != null && { Limit: input.Limit }),
4508
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4509
- ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
4510
- };
4511
- };
4512
- const se_ListWebACLsRequest = (input, context) => {
4513
- return {
4514
- ...(input.Limit != null && { Limit: input.Limit }),
4515
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4516
- };
4517
- };
4518
- const se_ListXssMatchSetsRequest = (input, context) => {
4519
- return {
4520
- ...(input.Limit != null && { Limit: input.Limit }),
4521
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4522
- };
4523
- };
4524
- const se_LogDestinationConfigs = (input, context) => {
4525
- return input
4526
- .filter((e) => e != null)
4527
- .map((entry) => {
4528
- return entry;
4529
- });
4530
- };
4531
- const se_LoggingConfiguration = (input, context) => {
4532
- return {
4533
- ...(input.LogDestinationConfigs != null && {
4534
- LogDestinationConfigs: se_LogDestinationConfigs(input.LogDestinationConfigs, context),
4535
- }),
4536
- ...(input.RedactedFields != null && { RedactedFields: se_RedactedFields(input.RedactedFields, context) }),
4537
- ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
4538
- };
4539
- };
4540
- const se_Predicate = (input, context) => {
4541
- return {
4542
- ...(input.DataId != null && { DataId: input.DataId }),
4543
- ...(input.Negated != null && { Negated: input.Negated }),
4544
- ...(input.Type != null && { Type: input.Type }),
4545
- };
4546
- };
4547
- const se_PutLoggingConfigurationRequest = (input, context) => {
4548
- return {
4549
- ...(input.LoggingConfiguration != null && {
4550
- LoggingConfiguration: se_LoggingConfiguration(input.LoggingConfiguration, context),
4551
- }),
4552
- };
4553
- };
4554
- const se_PutPermissionPolicyRequest = (input, context) => {
4555
- return {
4556
- ...(input.Policy != null && { Policy: input.Policy }),
4557
- ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
4558
- };
4559
- };
4560
- const se_RedactedFields = (input, context) => {
4561
- return input
4562
- .filter((e) => e != null)
4563
- .map((entry) => {
4564
- return se_FieldToMatch(entry, context);
4565
- });
4566
- };
4567
- const se_RegexMatchSetUpdate = (input, context) => {
4568
- return {
4569
- ...(input.Action != null && { Action: input.Action }),
4570
- ...(input.RegexMatchTuple != null && { RegexMatchTuple: se_RegexMatchTuple(input.RegexMatchTuple, context) }),
4571
- };
4572
- };
4573
- const se_RegexMatchSetUpdates = (input, context) => {
4574
- return input
4575
- .filter((e) => e != null)
4576
- .map((entry) => {
4577
- return se_RegexMatchSetUpdate(entry, context);
4578
- });
4579
- };
4580
- const se_RegexMatchTuple = (input, context) => {
4581
- return {
4582
- ...(input.FieldToMatch != null && { FieldToMatch: se_FieldToMatch(input.FieldToMatch, context) }),
4583
- ...(input.RegexPatternSetId != null && { RegexPatternSetId: input.RegexPatternSetId }),
4584
- ...(input.TextTransformation != null && { TextTransformation: input.TextTransformation }),
4585
- };
4586
- };
4587
- const se_RegexPatternSetUpdate = (input, context) => {
4588
- return {
4589
- ...(input.Action != null && { Action: input.Action }),
4590
- ...(input.RegexPatternString != null && { RegexPatternString: input.RegexPatternString }),
4591
- };
4592
- };
4593
- const se_RegexPatternSetUpdates = (input, context) => {
4594
- return input
4595
- .filter((e) => e != null)
4596
- .map((entry) => {
4597
- return se_RegexPatternSetUpdate(entry, context);
4598
- });
4599
- };
4600
- const se_RuleGroupUpdate = (input, context) => {
4601
- return {
4602
- ...(input.Action != null && { Action: input.Action }),
4603
- ...(input.ActivatedRule != null && { ActivatedRule: se_ActivatedRule(input.ActivatedRule, context) }),
4604
- };
4605
- };
4606
- const se_RuleGroupUpdates = (input, context) => {
4607
- return input
4608
- .filter((e) => e != null)
4609
- .map((entry) => {
4610
- return se_RuleGroupUpdate(entry, context);
4611
- });
4612
- };
4613
- const se_RuleUpdate = (input, context) => {
4614
- return {
4615
- ...(input.Action != null && { Action: input.Action }),
4616
- ...(input.Predicate != null && { Predicate: se_Predicate(input.Predicate, context) }),
4617
- };
4618
- };
4619
- const se_RuleUpdates = (input, context) => {
4620
- return input
4621
- .filter((e) => e != null)
4622
- .map((entry) => {
4623
- return se_RuleUpdate(entry, context);
4624
- });
4625
- };
4626
- const se_SizeConstraint = (input, context) => {
4627
- return {
4628
- ...(input.ComparisonOperator != null && { ComparisonOperator: input.ComparisonOperator }),
4629
- ...(input.FieldToMatch != null && { FieldToMatch: se_FieldToMatch(input.FieldToMatch, context) }),
4630
- ...(input.Size != null && { Size: input.Size }),
4631
- ...(input.TextTransformation != null && { TextTransformation: input.TextTransformation }),
4632
- };
4633
- };
4634
- const se_SizeConstraintSetUpdate = (input, context) => {
4635
- return {
4636
- ...(input.Action != null && { Action: input.Action }),
4637
- ...(input.SizeConstraint != null && { SizeConstraint: se_SizeConstraint(input.SizeConstraint, context) }),
4638
- };
4639
- };
4640
- const se_SizeConstraintSetUpdates = (input, context) => {
4641
- return input
4642
- .filter((e) => e != null)
4643
- .map((entry) => {
4644
- return se_SizeConstraintSetUpdate(entry, context);
4645
- });
4646
- };
4647
- const se_SqlInjectionMatchSetUpdate = (input, context) => {
4648
- return {
4649
- ...(input.Action != null && { Action: input.Action }),
4650
- ...(input.SqlInjectionMatchTuple != null && {
4651
- SqlInjectionMatchTuple: se_SqlInjectionMatchTuple(input.SqlInjectionMatchTuple, context),
4652
- }),
4653
- };
4654
- };
4655
- const se_SqlInjectionMatchSetUpdates = (input, context) => {
4656
- return input
4657
- .filter((e) => e != null)
4658
- .map((entry) => {
4659
- return se_SqlInjectionMatchSetUpdate(entry, context);
4660
- });
4661
- };
4662
- const se_SqlInjectionMatchTuple = (input, context) => {
4663
- return {
4664
- ...(input.FieldToMatch != null && { FieldToMatch: se_FieldToMatch(input.FieldToMatch, context) }),
4665
- ...(input.TextTransformation != null && { TextTransformation: input.TextTransformation }),
4666
- };
4667
- };
4668
- const se_Tag = (input, context) => {
4669
- return {
4670
- ...(input.Key != null && { Key: input.Key }),
4671
- ...(input.Value != null && { Value: input.Value }),
4672
- };
4673
- };
4674
- const se_TagKeyList = (input, context) => {
4675
- return input
4676
- .filter((e) => e != null)
4677
- .map((entry) => {
4678
- return entry;
4679
- });
4680
- };
4681
- const se_TagList = (input, context) => {
4682
- return input
4683
- .filter((e) => e != null)
4684
- .map((entry) => {
4685
- return se_Tag(entry, context);
4686
- });
4687
- };
4688
- const se_TagResourceRequest = (input, context) => {
4689
- return {
4690
- ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
4691
- ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
4692
- };
4693
- };
4694
- const se_TimeWindow = (input, context) => {
4695
- return {
4696
- ...(input.EndTime != null && { EndTime: Math.round(input.EndTime.getTime() / 1000) }),
4697
- ...(input.StartTime != null && { StartTime: Math.round(input.StartTime.getTime() / 1000) }),
4698
- };
4699
- };
4700
- const se_UntagResourceRequest = (input, context) => {
4701
- return {
4702
- ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
4703
- ...(input.TagKeys != null && { TagKeys: se_TagKeyList(input.TagKeys, context) }),
4704
- };
4705
- };
4706
- const se_UpdateByteMatchSetRequest = (input, context) => {
4707
- return {
4708
- ...(input.ByteMatchSetId != null && { ByteMatchSetId: input.ByteMatchSetId }),
4709
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4710
- ...(input.Updates != null && { Updates: se_ByteMatchSetUpdates(input.Updates, context) }),
4711
- };
4712
- };
4713
- const se_UpdateGeoMatchSetRequest = (input, context) => {
4714
- return {
4715
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4716
- ...(input.GeoMatchSetId != null && { GeoMatchSetId: input.GeoMatchSetId }),
4717
- ...(input.Updates != null && { Updates: se_GeoMatchSetUpdates(input.Updates, context) }),
4718
- };
4719
- };
4720
- const se_UpdateIPSetRequest = (input, context) => {
4721
- return {
4722
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4723
- ...(input.IPSetId != null && { IPSetId: input.IPSetId }),
4724
- ...(input.Updates != null && { Updates: se_IPSetUpdates(input.Updates, context) }),
4725
- };
4726
- };
4727
- const se_UpdateRateBasedRuleRequest = (input, context) => {
4728
- return {
4729
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4730
- ...(input.RateLimit != null && { RateLimit: input.RateLimit }),
4731
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4732
- ...(input.Updates != null && { Updates: se_RuleUpdates(input.Updates, context) }),
4733
- };
4734
- };
4735
- const se_UpdateRegexMatchSetRequest = (input, context) => {
4736
- return {
4737
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4738
- ...(input.RegexMatchSetId != null && { RegexMatchSetId: input.RegexMatchSetId }),
4739
- ...(input.Updates != null && { Updates: se_RegexMatchSetUpdates(input.Updates, context) }),
4740
- };
4741
- };
4742
- const se_UpdateRegexPatternSetRequest = (input, context) => {
4743
- return {
4744
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4745
- ...(input.RegexPatternSetId != null && { RegexPatternSetId: input.RegexPatternSetId }),
4746
- ...(input.Updates != null && { Updates: se_RegexPatternSetUpdates(input.Updates, context) }),
4747
- };
4748
- };
4749
- const se_UpdateRuleGroupRequest = (input, context) => {
4750
- return {
4751
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4752
- ...(input.RuleGroupId != null && { RuleGroupId: input.RuleGroupId }),
4753
- ...(input.Updates != null && { Updates: se_RuleGroupUpdates(input.Updates, context) }),
4754
- };
4755
- };
4756
- const se_UpdateRuleRequest = (input, context) => {
4757
- return {
4758
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4759
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4760
- ...(input.Updates != null && { Updates: se_RuleUpdates(input.Updates, context) }),
4761
- };
4762
- };
4763
- const se_UpdateSizeConstraintSetRequest = (input, context) => {
4764
- return {
4765
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4766
- ...(input.SizeConstraintSetId != null && { SizeConstraintSetId: input.SizeConstraintSetId }),
4767
- ...(input.Updates != null && { Updates: se_SizeConstraintSetUpdates(input.Updates, context) }),
4768
- };
4769
- };
4770
- const se_UpdateSqlInjectionMatchSetRequest = (input, context) => {
4771
- return {
4772
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4773
- ...(input.SqlInjectionMatchSetId != null && { SqlInjectionMatchSetId: input.SqlInjectionMatchSetId }),
4774
- ...(input.Updates != null && { Updates: se_SqlInjectionMatchSetUpdates(input.Updates, context) }),
4775
- };
4776
- };
4777
- const se_UpdateWebACLRequest = (input, context) => {
4778
- return {
4779
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4780
- ...(input.DefaultAction != null && { DefaultAction: se_WafAction(input.DefaultAction, context) }),
4781
- ...(input.Updates != null && { Updates: se_WebACLUpdates(input.Updates, context) }),
4782
- ...(input.WebACLId != null && { WebACLId: input.WebACLId }),
4783
- };
4784
- };
4785
- const se_UpdateXssMatchSetRequest = (input, context) => {
4786
- return {
4787
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4788
- ...(input.Updates != null && { Updates: se_XssMatchSetUpdates(input.Updates, context) }),
4789
- ...(input.XssMatchSetId != null && { XssMatchSetId: input.XssMatchSetId }),
4790
- };
4791
- };
4792
- const se_WafAction = (input, context) => {
4793
- return {
4794
- ...(input.Type != null && { Type: input.Type }),
4795
- };
4796
- };
4797
- const se_WafOverrideAction = (input, context) => {
4798
- return {
4799
- ...(input.Type != null && { Type: input.Type }),
4800
- };
4801
- };
4802
- const se_WebACLUpdate = (input, context) => {
4803
- return {
4804
- ...(input.Action != null && { Action: input.Action }),
4805
- ...(input.ActivatedRule != null && { ActivatedRule: se_ActivatedRule(input.ActivatedRule, context) }),
4806
- };
4807
- };
4808
- const se_WebACLUpdates = (input, context) => {
4809
- return input
4810
- .filter((e) => e != null)
4811
- .map((entry) => {
4812
- return se_WebACLUpdate(entry, context);
4813
- });
4814
- };
4815
- const se_XssMatchSetUpdate = (input, context) => {
4816
- return {
4817
- ...(input.Action != null && { Action: input.Action }),
4818
- ...(input.XssMatchTuple != null && { XssMatchTuple: se_XssMatchTuple(input.XssMatchTuple, context) }),
4819
- };
4820
- };
4821
- const se_XssMatchSetUpdates = (input, context) => {
4822
- return input
4823
- .filter((e) => e != null)
4824
- .map((entry) => {
4825
- return se_XssMatchSetUpdate(entry, context);
4826
- });
4827
- };
4828
- const se_XssMatchTuple = (input, context) => {
4829
- return {
4830
- ...(input.FieldToMatch != null && { FieldToMatch: se_FieldToMatch(input.FieldToMatch, context) }),
4831
- ...(input.TextTransformation != null && { TextTransformation: input.TextTransformation }),
4832
- };
4833
- };
4834
- const de_ActivatedRule = (output, context) => {
4835
- return {
4836
- Action: output.Action != null ? de_WafAction(output.Action, context) : undefined,
4837
- ExcludedRules: output.ExcludedRules != null ? de_ExcludedRules(output.ExcludedRules, context) : undefined,
4838
- OverrideAction: output.OverrideAction != null ? de_WafOverrideAction(output.OverrideAction, context) : undefined,
4839
- Priority: __expectInt32(output.Priority),
4840
- RuleId: __expectString(output.RuleId),
4841
- Type: __expectString(output.Type),
4842
- };
4843
- };
4844
- const de_ActivatedRules = (output, context) => {
4845
- const retVal = (output || [])
4846
- .filter((e) => e != null)
4847
- .map((entry) => {
4848
- if (entry === null) {
4849
- return null;
4850
- }
4851
- return de_ActivatedRule(entry, context);
4852
- });
4853
- return retVal;
4854
- };
4855
- const de_ByteMatchSet = (output, context) => {
4856
- return {
4857
- ByteMatchSetId: __expectString(output.ByteMatchSetId),
4858
- ByteMatchTuples: output.ByteMatchTuples != null ? de_ByteMatchTuples(output.ByteMatchTuples, context) : undefined,
4859
- Name: __expectString(output.Name),
4860
- };
4861
- };
4862
- const de_ByteMatchSetSummaries = (output, context) => {
4863
- const retVal = (output || [])
4864
- .filter((e) => e != null)
4865
- .map((entry) => {
4866
- if (entry === null) {
4867
- return null;
4868
- }
4869
- return de_ByteMatchSetSummary(entry, context);
4870
- });
4871
- return retVal;
4872
- };
4873
- const de_ByteMatchSetSummary = (output, context) => {
4874
- return {
4875
- ByteMatchSetId: __expectString(output.ByteMatchSetId),
4876
- Name: __expectString(output.Name),
4877
- };
4878
- };
4879
- const de_ByteMatchTuple = (output, context) => {
4880
- return {
4881
- FieldToMatch: output.FieldToMatch != null ? de_FieldToMatch(output.FieldToMatch, context) : undefined,
4882
- PositionalConstraint: __expectString(output.PositionalConstraint),
4883
- TargetString: output.TargetString != null ? context.base64Decoder(output.TargetString) : undefined,
4884
- TextTransformation: __expectString(output.TextTransformation),
4885
- };
4886
- };
4887
- const de_ByteMatchTuples = (output, context) => {
4888
- const retVal = (output || [])
4889
- .filter((e) => e != null)
4890
- .map((entry) => {
4891
- if (entry === null) {
4892
- return null;
4893
- }
4894
- return de_ByteMatchTuple(entry, context);
4895
- });
4896
- return retVal;
4897
- };
4898
- const de_CreateByteMatchSetResponse = (output, context) => {
4899
- return {
4900
- ByteMatchSet: output.ByteMatchSet != null ? de_ByteMatchSet(output.ByteMatchSet, context) : undefined,
4901
- ChangeToken: __expectString(output.ChangeToken),
4902
- };
4903
- };
4904
- const de_CreateGeoMatchSetResponse = (output, context) => {
4905
- return {
4906
- ChangeToken: __expectString(output.ChangeToken),
4907
- GeoMatchSet: output.GeoMatchSet != null ? de_GeoMatchSet(output.GeoMatchSet, context) : undefined,
4908
- };
4909
- };
4910
- const de_CreateIPSetResponse = (output, context) => {
4911
- return {
4912
- ChangeToken: __expectString(output.ChangeToken),
4913
- IPSet: output.IPSet != null ? de_IPSet(output.IPSet, context) : undefined,
4914
- };
4915
- };
4916
- const de_CreateRateBasedRuleResponse = (output, context) => {
4917
- return {
4918
- ChangeToken: __expectString(output.ChangeToken),
4919
- Rule: output.Rule != null ? de_RateBasedRule(output.Rule, context) : undefined,
4920
- };
4921
- };
4922
- const de_CreateRegexMatchSetResponse = (output, context) => {
4923
- return {
4924
- ChangeToken: __expectString(output.ChangeToken),
4925
- RegexMatchSet: output.RegexMatchSet != null ? de_RegexMatchSet(output.RegexMatchSet, context) : undefined,
4926
- };
4927
- };
4928
- const de_CreateRegexPatternSetResponse = (output, context) => {
4929
- return {
4930
- ChangeToken: __expectString(output.ChangeToken),
4931
- RegexPatternSet: output.RegexPatternSet != null ? de_RegexPatternSet(output.RegexPatternSet, context) : undefined,
4932
- };
4933
- };
4934
- const de_CreateRuleGroupResponse = (output, context) => {
4935
- return {
4936
- ChangeToken: __expectString(output.ChangeToken),
4937
- RuleGroup: output.RuleGroup != null ? de_RuleGroup(output.RuleGroup, context) : undefined,
4938
- };
4939
- };
4940
- const de_CreateRuleResponse = (output, context) => {
4941
- return {
4942
- ChangeToken: __expectString(output.ChangeToken),
4943
- Rule: output.Rule != null ? de_Rule(output.Rule, context) : undefined,
4944
- };
4945
- };
4946
- const de_CreateSizeConstraintSetResponse = (output, context) => {
4947
- return {
4948
- ChangeToken: __expectString(output.ChangeToken),
4949
- SizeConstraintSet: output.SizeConstraintSet != null ? de_SizeConstraintSet(output.SizeConstraintSet, context) : undefined,
4950
- };
4951
- };
4952
- const de_CreateSqlInjectionMatchSetResponse = (output, context) => {
4953
- return {
4954
- ChangeToken: __expectString(output.ChangeToken),
4955
- SqlInjectionMatchSet: output.SqlInjectionMatchSet != null ? de_SqlInjectionMatchSet(output.SqlInjectionMatchSet, context) : undefined,
4956
- };
4957
- };
4958
- const de_CreateWebACLMigrationStackResponse = (output, context) => {
4959
- return {
4960
- S3ObjectUrl: __expectString(output.S3ObjectUrl),
4961
- };
4962
- };
4963
- const de_CreateWebACLResponse = (output, context) => {
4964
- return {
4965
- ChangeToken: __expectString(output.ChangeToken),
4966
- WebACL: output.WebACL != null ? de_WebACL(output.WebACL, context) : undefined,
4967
- };
4968
- };
4969
- const de_CreateXssMatchSetResponse = (output, context) => {
4970
- return {
4971
- ChangeToken: __expectString(output.ChangeToken),
4972
- XssMatchSet: output.XssMatchSet != null ? de_XssMatchSet(output.XssMatchSet, context) : undefined,
4973
- };
4974
- };
4975
- const de_DeleteByteMatchSetResponse = (output, context) => {
4976
- return {
4977
- ChangeToken: __expectString(output.ChangeToken),
4978
- };
4979
- };
4980
- const de_DeleteGeoMatchSetResponse = (output, context) => {
4981
- return {
4982
- ChangeToken: __expectString(output.ChangeToken),
4983
- };
4984
- };
4985
- const de_DeleteIPSetResponse = (output, context) => {
4986
- return {
4987
- ChangeToken: __expectString(output.ChangeToken),
4988
- };
4989
- };
4990
- const de_DeleteLoggingConfigurationResponse = (output, context) => {
4991
- return {};
4992
- };
4993
- const de_DeletePermissionPolicyResponse = (output, context) => {
4994
- return {};
4995
- };
4996
- const de_DeleteRateBasedRuleResponse = (output, context) => {
4997
- return {
4998
- ChangeToken: __expectString(output.ChangeToken),
4999
- };
5000
- };
5001
- const de_DeleteRegexMatchSetResponse = (output, context) => {
5002
- return {
5003
- ChangeToken: __expectString(output.ChangeToken),
5004
- };
5005
- };
5006
- const de_DeleteRegexPatternSetResponse = (output, context) => {
5007
- return {
5008
- ChangeToken: __expectString(output.ChangeToken),
5009
- };
5010
- };
5011
- const de_DeleteRuleGroupResponse = (output, context) => {
5012
- return {
5013
- ChangeToken: __expectString(output.ChangeToken),
5014
- };
5015
- };
5016
- const de_DeleteRuleResponse = (output, context) => {
5017
- return {
5018
- ChangeToken: __expectString(output.ChangeToken),
5019
- };
5020
- };
5021
- const de_DeleteSizeConstraintSetResponse = (output, context) => {
5022
- return {
5023
- ChangeToken: __expectString(output.ChangeToken),
5024
- };
5025
- };
5026
- const de_DeleteSqlInjectionMatchSetResponse = (output, context) => {
5027
- return {
5028
- ChangeToken: __expectString(output.ChangeToken),
5029
- };
5030
- };
5031
- const de_DeleteWebACLResponse = (output, context) => {
5032
- return {
5033
- ChangeToken: __expectString(output.ChangeToken),
5034
- };
5035
- };
5036
- const de_DeleteXssMatchSetResponse = (output, context) => {
5037
- return {
5038
- ChangeToken: __expectString(output.ChangeToken),
5039
- };
5040
- };
5041
- const de_ExcludedRule = (output, context) => {
5042
- return {
5043
- RuleId: __expectString(output.RuleId),
5044
- };
5045
- };
5046
- const de_ExcludedRules = (output, context) => {
5047
- const retVal = (output || [])
5048
- .filter((e) => e != null)
5049
- .map((entry) => {
5050
- if (entry === null) {
5051
- return null;
5052
- }
5053
- return de_ExcludedRule(entry, context);
5054
- });
5055
- return retVal;
5056
- };
5057
- const de_FieldToMatch = (output, context) => {
5058
- return {
5059
- Data: __expectString(output.Data),
5060
- Type: __expectString(output.Type),
5061
- };
5062
- };
5063
- const de_GeoMatchConstraint = (output, context) => {
5064
- return {
5065
- Type: __expectString(output.Type),
5066
- Value: __expectString(output.Value),
5067
- };
5068
- };
5069
- const de_GeoMatchConstraints = (output, context) => {
5070
- const retVal = (output || [])
5071
- .filter((e) => e != null)
5072
- .map((entry) => {
5073
- if (entry === null) {
5074
- return null;
5075
- }
5076
- return de_GeoMatchConstraint(entry, context);
5077
- });
5078
- return retVal;
5079
- };
5080
- const de_GeoMatchSet = (output, context) => {
5081
- return {
5082
- GeoMatchConstraints: output.GeoMatchConstraints != null ? de_GeoMatchConstraints(output.GeoMatchConstraints, context) : undefined,
5083
- GeoMatchSetId: __expectString(output.GeoMatchSetId),
5084
- Name: __expectString(output.Name),
5085
- };
5086
- };
5087
- const de_GeoMatchSetSummaries = (output, context) => {
5088
- const retVal = (output || [])
5089
- .filter((e) => e != null)
5090
- .map((entry) => {
5091
- if (entry === null) {
5092
- return null;
5093
- }
5094
- return de_GeoMatchSetSummary(entry, context);
5095
- });
5096
- return retVal;
5097
- };
5098
- const de_GeoMatchSetSummary = (output, context) => {
5099
- return {
5100
- GeoMatchSetId: __expectString(output.GeoMatchSetId),
5101
- Name: __expectString(output.Name),
5102
- };
5103
- };
5104
- const de_GetByteMatchSetResponse = (output, context) => {
5105
- return {
5106
- ByteMatchSet: output.ByteMatchSet != null ? de_ByteMatchSet(output.ByteMatchSet, context) : undefined,
5107
- };
5108
- };
5109
- const de_GetChangeTokenResponse = (output, context) => {
5110
- return {
5111
- ChangeToken: __expectString(output.ChangeToken),
5112
- };
5113
- };
5114
- const de_GetChangeTokenStatusResponse = (output, context) => {
5115
- return {
5116
- ChangeTokenStatus: __expectString(output.ChangeTokenStatus),
5117
- };
5118
- };
5119
- const de_GetGeoMatchSetResponse = (output, context) => {
5120
- return {
5121
- GeoMatchSet: output.GeoMatchSet != null ? de_GeoMatchSet(output.GeoMatchSet, context) : undefined,
5122
- };
5123
- };
5124
- const de_GetIPSetResponse = (output, context) => {
5125
- return {
5126
- IPSet: output.IPSet != null ? de_IPSet(output.IPSet, context) : undefined,
5127
- };
5128
- };
5129
- const de_GetLoggingConfigurationResponse = (output, context) => {
5130
- return {
5131
- LoggingConfiguration: output.LoggingConfiguration != null ? de_LoggingConfiguration(output.LoggingConfiguration, context) : undefined,
5132
- };
5133
- };
5134
- const de_GetPermissionPolicyResponse = (output, context) => {
5135
- return {
5136
- Policy: __expectString(output.Policy),
5137
- };
5138
- };
5139
- const de_GetRateBasedRuleManagedKeysResponse = (output, context) => {
5140
- return {
5141
- ManagedKeys: output.ManagedKeys != null ? de_ManagedKeys(output.ManagedKeys, context) : undefined,
5142
- NextMarker: __expectString(output.NextMarker),
5143
- };
5144
- };
5145
- const de_GetRateBasedRuleResponse = (output, context) => {
5146
- return {
5147
- Rule: output.Rule != null ? de_RateBasedRule(output.Rule, context) : undefined,
5148
- };
5149
- };
5150
- const de_GetRegexMatchSetResponse = (output, context) => {
5151
- return {
5152
- RegexMatchSet: output.RegexMatchSet != null ? de_RegexMatchSet(output.RegexMatchSet, context) : undefined,
5153
- };
5154
- };
5155
- const de_GetRegexPatternSetResponse = (output, context) => {
5156
- return {
5157
- RegexPatternSet: output.RegexPatternSet != null ? de_RegexPatternSet(output.RegexPatternSet, context) : undefined,
5158
- };
5159
- };
5160
- const de_GetRuleGroupResponse = (output, context) => {
5161
- return {
5162
- RuleGroup: output.RuleGroup != null ? de_RuleGroup(output.RuleGroup, context) : undefined,
5163
- };
5164
- };
5165
- const de_GetRuleResponse = (output, context) => {
5166
- return {
5167
- Rule: output.Rule != null ? de_Rule(output.Rule, context) : undefined,
5168
- };
5169
- };
5170
- const de_GetSampledRequestsResponse = (output, context) => {
5171
- return {
5172
- PopulationSize: __expectLong(output.PopulationSize),
5173
- SampledRequests: output.SampledRequests != null ? de_SampledHTTPRequests(output.SampledRequests, context) : undefined,
5174
- TimeWindow: output.TimeWindow != null ? de_TimeWindow(output.TimeWindow, context) : undefined,
5175
- };
5176
- };
5177
- const de_GetSizeConstraintSetResponse = (output, context) => {
5178
- return {
5179
- SizeConstraintSet: output.SizeConstraintSet != null ? de_SizeConstraintSet(output.SizeConstraintSet, context) : undefined,
5180
- };
5181
- };
5182
- const de_GetSqlInjectionMatchSetResponse = (output, context) => {
5183
- return {
5184
- SqlInjectionMatchSet: output.SqlInjectionMatchSet != null ? de_SqlInjectionMatchSet(output.SqlInjectionMatchSet, context) : undefined,
5185
- };
5186
- };
5187
- const de_GetWebACLResponse = (output, context) => {
5188
- return {
5189
- WebACL: output.WebACL != null ? de_WebACL(output.WebACL, context) : undefined,
5190
- };
5191
- };
5192
- const de_GetXssMatchSetResponse = (output, context) => {
5193
- return {
5194
- XssMatchSet: output.XssMatchSet != null ? de_XssMatchSet(output.XssMatchSet, context) : undefined,
5195
- };
5196
- };
5197
- const de_HTTPHeader = (output, context) => {
5198
- return {
5199
- Name: __expectString(output.Name),
5200
- Value: __expectString(output.Value),
5201
- };
5202
- };
5203
- const de_HTTPHeaders = (output, context) => {
5204
- const retVal = (output || [])
5205
- .filter((e) => e != null)
5206
- .map((entry) => {
5207
- if (entry === null) {
5208
- return null;
5209
- }
5210
- return de_HTTPHeader(entry, context);
5211
- });
5212
- return retVal;
5213
- };
5214
- const de_HTTPRequest = (output, context) => {
5215
- return {
5216
- ClientIP: __expectString(output.ClientIP),
5217
- Country: __expectString(output.Country),
5218
- HTTPVersion: __expectString(output.HTTPVersion),
5219
- Headers: output.Headers != null ? de_HTTPHeaders(output.Headers, context) : undefined,
5220
- Method: __expectString(output.Method),
5221
- URI: __expectString(output.URI),
5222
- };
5223
- };
5224
- const de_IPSet = (output, context) => {
5225
- return {
5226
- IPSetDescriptors: output.IPSetDescriptors != null ? de_IPSetDescriptors(output.IPSetDescriptors, context) : undefined,
5227
- IPSetId: __expectString(output.IPSetId),
5228
- Name: __expectString(output.Name),
5229
- };
5230
- };
5231
- const de_IPSetDescriptor = (output, context) => {
5232
- return {
5233
- Type: __expectString(output.Type),
5234
- Value: __expectString(output.Value),
5235
- };
5236
- };
5237
- const de_IPSetDescriptors = (output, context) => {
5238
- const retVal = (output || [])
5239
- .filter((e) => e != null)
5240
- .map((entry) => {
5241
- if (entry === null) {
5242
- return null;
5243
- }
5244
- return de_IPSetDescriptor(entry, context);
5245
- });
5246
- return retVal;
5247
- };
5248
- const de_IPSetSummaries = (output, context) => {
5249
- const retVal = (output || [])
5250
- .filter((e) => e != null)
5251
- .map((entry) => {
5252
- if (entry === null) {
5253
- return null;
5254
- }
5255
- return de_IPSetSummary(entry, context);
5256
- });
5257
- return retVal;
5258
- };
5259
- const de_IPSetSummary = (output, context) => {
5260
- return {
5261
- IPSetId: __expectString(output.IPSetId),
5262
- Name: __expectString(output.Name),
5263
- };
5264
- };
5265
- const de_ListActivatedRulesInRuleGroupResponse = (output, context) => {
5266
- return {
5267
- ActivatedRules: output.ActivatedRules != null ? de_ActivatedRules(output.ActivatedRules, context) : undefined,
5268
- NextMarker: __expectString(output.NextMarker),
5269
- };
5270
- };
5271
- const de_ListByteMatchSetsResponse = (output, context) => {
5272
- return {
5273
- ByteMatchSets: output.ByteMatchSets != null ? de_ByteMatchSetSummaries(output.ByteMatchSets, context) : undefined,
5274
- NextMarker: __expectString(output.NextMarker),
5275
- };
5276
- };
5277
- const de_ListGeoMatchSetsResponse = (output, context) => {
5278
- return {
5279
- GeoMatchSets: output.GeoMatchSets != null ? de_GeoMatchSetSummaries(output.GeoMatchSets, context) : undefined,
5280
- NextMarker: __expectString(output.NextMarker),
5281
- };
5282
- };
5283
- const de_ListIPSetsResponse = (output, context) => {
5284
- return {
5285
- IPSets: output.IPSets != null ? de_IPSetSummaries(output.IPSets, context) : undefined,
5286
- NextMarker: __expectString(output.NextMarker),
5287
- };
5288
- };
5289
- const de_ListLoggingConfigurationsResponse = (output, context) => {
5290
- return {
5291
- LoggingConfigurations: output.LoggingConfigurations != null
5292
- ? de_LoggingConfigurations(output.LoggingConfigurations, context)
5293
- : undefined,
5294
- NextMarker: __expectString(output.NextMarker),
5295
- };
5296
- };
5297
- const de_ListRateBasedRulesResponse = (output, context) => {
5298
- return {
5299
- NextMarker: __expectString(output.NextMarker),
5300
- Rules: output.Rules != null ? de_RuleSummaries(output.Rules, context) : undefined,
5301
- };
5302
- };
5303
- const de_ListRegexMatchSetsResponse = (output, context) => {
5304
- return {
5305
- NextMarker: __expectString(output.NextMarker),
5306
- RegexMatchSets: output.RegexMatchSets != null ? de_RegexMatchSetSummaries(output.RegexMatchSets, context) : undefined,
5307
- };
5308
- };
5309
- const de_ListRegexPatternSetsResponse = (output, context) => {
5310
- return {
5311
- NextMarker: __expectString(output.NextMarker),
5312
- RegexPatternSets: output.RegexPatternSets != null ? de_RegexPatternSetSummaries(output.RegexPatternSets, context) : undefined,
5313
- };
5314
- };
5315
- const de_ListRuleGroupsResponse = (output, context) => {
5316
- return {
5317
- NextMarker: __expectString(output.NextMarker),
5318
- RuleGroups: output.RuleGroups != null ? de_RuleGroupSummaries(output.RuleGroups, context) : undefined,
5319
- };
5320
- };
5321
- const de_ListRulesResponse = (output, context) => {
5322
- return {
5323
- NextMarker: __expectString(output.NextMarker),
5324
- Rules: output.Rules != null ? de_RuleSummaries(output.Rules, context) : undefined,
5325
- };
5326
- };
5327
- const de_ListSizeConstraintSetsResponse = (output, context) => {
5328
- return {
5329
- NextMarker: __expectString(output.NextMarker),
5330
- SizeConstraintSets: output.SizeConstraintSets != null ? de_SizeConstraintSetSummaries(output.SizeConstraintSets, context) : undefined,
5331
- };
5332
- };
5333
- const de_ListSqlInjectionMatchSetsResponse = (output, context) => {
5334
- return {
5335
- NextMarker: __expectString(output.NextMarker),
5336
- SqlInjectionMatchSets: output.SqlInjectionMatchSets != null
5337
- ? de_SqlInjectionMatchSetSummaries(output.SqlInjectionMatchSets, context)
5338
- : undefined,
5339
- };
5340
- };
5341
- const de_ListSubscribedRuleGroupsResponse = (output, context) => {
5342
- return {
5343
- NextMarker: __expectString(output.NextMarker),
5344
- RuleGroups: output.RuleGroups != null ? de_SubscribedRuleGroupSummaries(output.RuleGroups, context) : undefined,
5345
- };
5346
- };
5347
- const de_ListTagsForResourceResponse = (output, context) => {
5348
- return {
5349
- NextMarker: __expectString(output.NextMarker),
5350
- TagInfoForResource: output.TagInfoForResource != null ? de_TagInfoForResource(output.TagInfoForResource, context) : undefined,
5351
- };
5352
- };
5353
- const de_ListWebACLsResponse = (output, context) => {
5354
- return {
5355
- NextMarker: __expectString(output.NextMarker),
5356
- WebACLs: output.WebACLs != null ? de_WebACLSummaries(output.WebACLs, context) : undefined,
5357
- };
5358
- };
5359
- const de_ListXssMatchSetsResponse = (output, context) => {
5360
- return {
5361
- NextMarker: __expectString(output.NextMarker),
5362
- XssMatchSets: output.XssMatchSets != null ? de_XssMatchSetSummaries(output.XssMatchSets, context) : undefined,
5363
- };
5364
- };
5365
- const de_LogDestinationConfigs = (output, context) => {
5366
- const retVal = (output || [])
5367
- .filter((e) => e != null)
5368
- .map((entry) => {
5369
- if (entry === null) {
5370
- return null;
5371
- }
5372
- return __expectString(entry);
5373
- });
5374
- return retVal;
5375
- };
5376
- const de_LoggingConfiguration = (output, context) => {
5377
- return {
5378
- LogDestinationConfigs: output.LogDestinationConfigs != null
5379
- ? de_LogDestinationConfigs(output.LogDestinationConfigs, context)
5380
- : undefined,
5381
- RedactedFields: output.RedactedFields != null ? de_RedactedFields(output.RedactedFields, context) : undefined,
5382
- ResourceArn: __expectString(output.ResourceArn),
5383
- };
5384
- };
5385
- const de_LoggingConfigurations = (output, context) => {
5386
- const retVal = (output || [])
5387
- .filter((e) => e != null)
5388
- .map((entry) => {
5389
- if (entry === null) {
5390
- return null;
5391
- }
5392
- return de_LoggingConfiguration(entry, context);
5393
- });
5394
- return retVal;
5395
- };
5396
- const de_ManagedKeys = (output, context) => {
5397
- const retVal = (output || [])
5398
- .filter((e) => e != null)
5399
- .map((entry) => {
5400
- if (entry === null) {
5401
- return null;
5402
- }
5403
- return __expectString(entry);
5404
- });
5405
- return retVal;
5406
- };
5407
- const de_Predicate = (output, context) => {
5408
- return {
5409
- DataId: __expectString(output.DataId),
5410
- Negated: __expectBoolean(output.Negated),
5411
- Type: __expectString(output.Type),
5412
- };
5413
- };
5414
- const de_Predicates = (output, context) => {
5415
- const retVal = (output || [])
5416
- .filter((e) => e != null)
5417
- .map((entry) => {
5418
- if (entry === null) {
5419
- return null;
5420
- }
5421
- return de_Predicate(entry, context);
5422
- });
5423
- return retVal;
5424
- };
5425
- const de_PutLoggingConfigurationResponse = (output, context) => {
5426
- return {
5427
- LoggingConfiguration: output.LoggingConfiguration != null ? de_LoggingConfiguration(output.LoggingConfiguration, context) : undefined,
5428
- };
5429
- };
5430
- const de_PutPermissionPolicyResponse = (output, context) => {
5431
- return {};
5432
- };
5433
- const de_RateBasedRule = (output, context) => {
5434
- return {
5435
- MatchPredicates: output.MatchPredicates != null ? de_Predicates(output.MatchPredicates, context) : undefined,
5436
- MetricName: __expectString(output.MetricName),
5437
- Name: __expectString(output.Name),
5438
- RateKey: __expectString(output.RateKey),
5439
- RateLimit: __expectLong(output.RateLimit),
5440
- RuleId: __expectString(output.RuleId),
5441
- };
5442
- };
5443
- const de_RedactedFields = (output, context) => {
5444
- const retVal = (output || [])
5445
- .filter((e) => e != null)
5446
- .map((entry) => {
5447
- if (entry === null) {
5448
- return null;
5449
- }
5450
- return de_FieldToMatch(entry, context);
5451
- });
5452
- return retVal;
5453
- };
5454
- const de_RegexMatchSet = (output, context) => {
5455
- return {
5456
- Name: __expectString(output.Name),
5457
- RegexMatchSetId: __expectString(output.RegexMatchSetId),
5458
- RegexMatchTuples: output.RegexMatchTuples != null ? de_RegexMatchTuples(output.RegexMatchTuples, context) : undefined,
5459
- };
5460
- };
5461
- const de_RegexMatchSetSummaries = (output, context) => {
5462
- const retVal = (output || [])
5463
- .filter((e) => e != null)
5464
- .map((entry) => {
5465
- if (entry === null) {
5466
- return null;
5467
- }
5468
- return de_RegexMatchSetSummary(entry, context);
5469
- });
5470
- return retVal;
5471
- };
5472
- const de_RegexMatchSetSummary = (output, context) => {
5473
- return {
5474
- Name: __expectString(output.Name),
5475
- RegexMatchSetId: __expectString(output.RegexMatchSetId),
5476
- };
5477
- };
5478
- const de_RegexMatchTuple = (output, context) => {
5479
- return {
5480
- FieldToMatch: output.FieldToMatch != null ? de_FieldToMatch(output.FieldToMatch, context) : undefined,
5481
- RegexPatternSetId: __expectString(output.RegexPatternSetId),
5482
- TextTransformation: __expectString(output.TextTransformation),
5483
- };
5484
- };
5485
- const de_RegexMatchTuples = (output, context) => {
5486
- const retVal = (output || [])
5487
- .filter((e) => e != null)
5488
- .map((entry) => {
5489
- if (entry === null) {
5490
- return null;
5491
- }
5492
- return de_RegexMatchTuple(entry, context);
3996
+ const se_ByteMatchSetUpdate = (input, context) => {
3997
+ return take(input, {
3998
+ Action: [],
3999
+ ByteMatchTuple: (_) => se_ByteMatchTuple(_, context),
5493
4000
  });
5494
- return retVal;
5495
- };
5496
- const de_RegexPatternSet = (output, context) => {
5497
- return {
5498
- Name: __expectString(output.Name),
5499
- RegexPatternSetId: __expectString(output.RegexPatternSetId),
5500
- RegexPatternStrings: output.RegexPatternStrings != null ? de_RegexPatternStrings(output.RegexPatternStrings, context) : undefined,
5501
- };
5502
4001
  };
5503
- const de_RegexPatternSetSummaries = (output, context) => {
5504
- const retVal = (output || [])
4002
+ const se_ByteMatchSetUpdates = (input, context) => {
4003
+ return input
5505
4004
  .filter((e) => e != null)
5506
4005
  .map((entry) => {
5507
- if (entry === null) {
5508
- return null;
5509
- }
5510
- return de_RegexPatternSetSummary(entry, context);
4006
+ return se_ByteMatchSetUpdate(entry, context);
5511
4007
  });
5512
- return retVal;
5513
- };
5514
- const de_RegexPatternSetSummary = (output, context) => {
5515
- return {
5516
- Name: __expectString(output.Name),
5517
- RegexPatternSetId: __expectString(output.RegexPatternSetId),
5518
- };
5519
4008
  };
5520
- const de_RegexPatternStrings = (output, context) => {
5521
- const retVal = (output || [])
5522
- .filter((e) => e != null)
5523
- .map((entry) => {
5524
- if (entry === null) {
5525
- return null;
5526
- }
5527
- return __expectString(entry);
4009
+ const se_ByteMatchTuple = (input, context) => {
4010
+ return take(input, {
4011
+ FieldToMatch: _json,
4012
+ PositionalConstraint: [],
4013
+ TargetString: context.base64Encoder,
4014
+ TextTransformation: [],
5528
4015
  });
5529
- return retVal;
5530
4016
  };
5531
- const de_Rule = (output, context) => {
5532
- return {
5533
- MetricName: __expectString(output.MetricName),
5534
- Name: __expectString(output.Name),
5535
- Predicates: output.Predicates != null ? de_Predicates(output.Predicates, context) : undefined,
5536
- RuleId: __expectString(output.RuleId),
5537
- };
5538
- };
5539
- const de_RuleGroup = (output, context) => {
5540
- return {
5541
- MetricName: __expectString(output.MetricName),
5542
- Name: __expectString(output.Name),
5543
- RuleGroupId: __expectString(output.RuleGroupId),
5544
- };
5545
- };
5546
- const de_RuleGroupSummaries = (output, context) => {
5547
- const retVal = (output || [])
5548
- .filter((e) => e != null)
5549
- .map((entry) => {
5550
- if (entry === null) {
5551
- return null;
5552
- }
5553
- return de_RuleGroupSummary(entry, context);
4017
+ const se_GetSampledRequestsRequest = (input, context) => {
4018
+ return take(input, {
4019
+ MaxItems: [],
4020
+ RuleId: [],
4021
+ TimeWindow: (_) => se_TimeWindow(_, context),
4022
+ WebAclId: [],
5554
4023
  });
5555
- return retVal;
5556
4024
  };
5557
- const de_RuleGroupSummary = (output, context) => {
5558
- return {
5559
- Name: __expectString(output.Name),
5560
- RuleGroupId: __expectString(output.RuleGroupId),
5561
- };
5562
- };
5563
- const de_RuleSummaries = (output, context) => {
5564
- const retVal = (output || [])
5565
- .filter((e) => e != null)
5566
- .map((entry) => {
5567
- if (entry === null) {
5568
- return null;
5569
- }
5570
- return de_RuleSummary(entry, context);
4025
+ const se_TimeWindow = (input, context) => {
4026
+ return take(input, {
4027
+ EndTime: (_) => Math.round(_.getTime() / 1000),
4028
+ StartTime: (_) => Math.round(_.getTime() / 1000),
5571
4029
  });
5572
- return retVal;
5573
- };
5574
- const de_RuleSummary = (output, context) => {
5575
- return {
5576
- Name: __expectString(output.Name),
5577
- RuleId: __expectString(output.RuleId),
5578
- };
5579
4030
  };
5580
- const de_SampledHTTPRequest = (output, context) => {
5581
- return {
5582
- Action: __expectString(output.Action),
5583
- Request: output.Request != null ? de_HTTPRequest(output.Request, context) : undefined,
5584
- RuleWithinRuleGroup: __expectString(output.RuleWithinRuleGroup),
5585
- Timestamp: output.Timestamp != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.Timestamp))) : undefined,
5586
- Weight: __expectLong(output.Weight),
5587
- };
5588
- };
5589
- const de_SampledHTTPRequests = (output, context) => {
5590
- const retVal = (output || [])
5591
- .filter((e) => e != null)
5592
- .map((entry) => {
5593
- if (entry === null) {
5594
- return null;
5595
- }
5596
- return de_SampledHTTPRequest(entry, context);
4031
+ const se_UpdateByteMatchSetRequest = (input, context) => {
4032
+ return take(input, {
4033
+ ByteMatchSetId: [],
4034
+ ChangeToken: [],
4035
+ Updates: (_) => se_ByteMatchSetUpdates(_, context),
5597
4036
  });
5598
- return retVal;
5599
4037
  };
5600
- const de_SizeConstraint = (output, context) => {
5601
- return {
5602
- ComparisonOperator: __expectString(output.ComparisonOperator),
5603
- FieldToMatch: output.FieldToMatch != null ? de_FieldToMatch(output.FieldToMatch, context) : undefined,
5604
- Size: __expectLong(output.Size),
5605
- TextTransformation: __expectString(output.TextTransformation),
5606
- };
5607
- };
5608
- const de_SizeConstraints = (output, context) => {
5609
- const retVal = (output || [])
5610
- .filter((e) => e != null)
5611
- .map((entry) => {
5612
- if (entry === null) {
5613
- return null;
5614
- }
5615
- return de_SizeConstraint(entry, context);
4038
+ const de_ByteMatchSet = (output, context) => {
4039
+ return take(output, {
4040
+ ByteMatchSetId: __expectString,
4041
+ ByteMatchTuples: (_) => de_ByteMatchTuples(_, context),
4042
+ Name: __expectString,
5616
4043
  });
5617
- return retVal;
5618
- };
5619
- const de_SizeConstraintSet = (output, context) => {
5620
- return {
5621
- Name: __expectString(output.Name),
5622
- SizeConstraintSetId: __expectString(output.SizeConstraintSetId),
5623
- SizeConstraints: output.SizeConstraints != null ? de_SizeConstraints(output.SizeConstraints, context) : undefined,
5624
- };
5625
4044
  };
5626
- const de_SizeConstraintSetSummaries = (output, context) => {
5627
- const retVal = (output || [])
5628
- .filter((e) => e != null)
5629
- .map((entry) => {
5630
- if (entry === null) {
5631
- return null;
5632
- }
5633
- return de_SizeConstraintSetSummary(entry, context);
4045
+ const de_ByteMatchTuple = (output, context) => {
4046
+ return take(output, {
4047
+ FieldToMatch: _json,
4048
+ PositionalConstraint: __expectString,
4049
+ TargetString: context.base64Decoder,
4050
+ TextTransformation: __expectString,
5634
4051
  });
5635
- return retVal;
5636
- };
5637
- const de_SizeConstraintSetSummary = (output, context) => {
5638
- return {
5639
- Name: __expectString(output.Name),
5640
- SizeConstraintSetId: __expectString(output.SizeConstraintSetId),
5641
- };
5642
- };
5643
- const de_SqlInjectionMatchSet = (output, context) => {
5644
- return {
5645
- Name: __expectString(output.Name),
5646
- SqlInjectionMatchSetId: __expectString(output.SqlInjectionMatchSetId),
5647
- SqlInjectionMatchTuples: output.SqlInjectionMatchTuples != null
5648
- ? de_SqlInjectionMatchTuples(output.SqlInjectionMatchTuples, context)
5649
- : undefined,
5650
- };
5651
4052
  };
5652
- const de_SqlInjectionMatchSetSummaries = (output, context) => {
4053
+ const de_ByteMatchTuples = (output, context) => {
5653
4054
  const retVal = (output || [])
5654
4055
  .filter((e) => e != null)
5655
4056
  .map((entry) => {
5656
- if (entry === null) {
5657
- return null;
5658
- }
5659
- return de_SqlInjectionMatchSetSummary(entry, context);
4057
+ return de_ByteMatchTuple(entry, context);
5660
4058
  });
5661
4059
  return retVal;
5662
4060
  };
5663
- const de_SqlInjectionMatchSetSummary = (output, context) => {
5664
- return {
5665
- Name: __expectString(output.Name),
5666
- SqlInjectionMatchSetId: __expectString(output.SqlInjectionMatchSetId),
5667
- };
5668
- };
5669
- const de_SqlInjectionMatchTuple = (output, context) => {
5670
- return {
5671
- FieldToMatch: output.FieldToMatch != null ? de_FieldToMatch(output.FieldToMatch, context) : undefined,
5672
- TextTransformation: __expectString(output.TextTransformation),
5673
- };
5674
- };
5675
- const de_SqlInjectionMatchTuples = (output, context) => {
5676
- const retVal = (output || [])
5677
- .filter((e) => e != null)
5678
- .map((entry) => {
5679
- if (entry === null) {
5680
- return null;
5681
- }
5682
- return de_SqlInjectionMatchTuple(entry, context);
4061
+ const de_CreateByteMatchSetResponse = (output, context) => {
4062
+ return take(output, {
4063
+ ByteMatchSet: (_) => de_ByteMatchSet(_, context),
4064
+ ChangeToken: __expectString,
5683
4065
  });
5684
- return retVal;
5685
4066
  };
5686
- const de_SubscribedRuleGroupSummaries = (output, context) => {
5687
- const retVal = (output || [])
5688
- .filter((e) => e != null)
5689
- .map((entry) => {
5690
- if (entry === null) {
5691
- return null;
5692
- }
5693
- return de_SubscribedRuleGroupSummary(entry, context);
4067
+ const de_GetByteMatchSetResponse = (output, context) => {
4068
+ return take(output, {
4069
+ ByteMatchSet: (_) => de_ByteMatchSet(_, context),
5694
4070
  });
5695
- return retVal;
5696
- };
5697
- const de_SubscribedRuleGroupSummary = (output, context) => {
5698
- return {
5699
- MetricName: __expectString(output.MetricName),
5700
- Name: __expectString(output.Name),
5701
- RuleGroupId: __expectString(output.RuleGroupId),
5702
- };
5703
- };
5704
- const de_Tag = (output, context) => {
5705
- return {
5706
- Key: __expectString(output.Key),
5707
- Value: __expectString(output.Value),
5708
- };
5709
- };
5710
- const de_TagInfoForResource = (output, context) => {
5711
- return {
5712
- ResourceARN: __expectString(output.ResourceARN),
5713
- TagList: output.TagList != null ? de_TagList(output.TagList, context) : undefined,
5714
- };
5715
4071
  };
5716
- const de_TagList = (output, context) => {
5717
- const retVal = (output || [])
5718
- .filter((e) => e != null)
5719
- .map((entry) => {
5720
- if (entry === null) {
5721
- return null;
5722
- }
5723
- return de_Tag(entry, context);
4072
+ const de_GetSampledRequestsResponse = (output, context) => {
4073
+ return take(output, {
4074
+ PopulationSize: __expectLong,
4075
+ SampledRequests: (_) => de_SampledHTTPRequests(_, context),
4076
+ TimeWindow: (_) => de_TimeWindow(_, context),
5724
4077
  });
5725
- return retVal;
5726
- };
5727
- const de_TagResourceResponse = (output, context) => {
5728
- return {};
5729
- };
5730
- const de_TimeWindow = (output, context) => {
5731
- return {
5732
- EndTime: output.EndTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.EndTime))) : undefined,
5733
- StartTime: output.StartTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartTime))) : undefined,
5734
- };
5735
- };
5736
- const de_UntagResourceResponse = (output, context) => {
5737
- return {};
5738
4078
  };
5739
- const de_UpdateByteMatchSetResponse = (output, context) => {
5740
- return {
5741
- ChangeToken: __expectString(output.ChangeToken),
5742
- };
5743
- };
5744
- const de_UpdateGeoMatchSetResponse = (output, context) => {
5745
- return {
5746
- ChangeToken: __expectString(output.ChangeToken),
5747
- };
5748
- };
5749
- const de_UpdateIPSetResponse = (output, context) => {
5750
- return {
5751
- ChangeToken: __expectString(output.ChangeToken),
5752
- };
5753
- };
5754
- const de_UpdateRateBasedRuleResponse = (output, context) => {
5755
- return {
5756
- ChangeToken: __expectString(output.ChangeToken),
5757
- };
5758
- };
5759
- const de_UpdateRegexMatchSetResponse = (output, context) => {
5760
- return {
5761
- ChangeToken: __expectString(output.ChangeToken),
5762
- };
5763
- };
5764
- const de_UpdateRegexPatternSetResponse = (output, context) => {
5765
- return {
5766
- ChangeToken: __expectString(output.ChangeToken),
5767
- };
5768
- };
5769
- const de_UpdateRuleGroupResponse = (output, context) => {
5770
- return {
5771
- ChangeToken: __expectString(output.ChangeToken),
5772
- };
5773
- };
5774
- const de_UpdateRuleResponse = (output, context) => {
5775
- return {
5776
- ChangeToken: __expectString(output.ChangeToken),
5777
- };
5778
- };
5779
- const de_UpdateSizeConstraintSetResponse = (output, context) => {
5780
- return {
5781
- ChangeToken: __expectString(output.ChangeToken),
5782
- };
5783
- };
5784
- const de_UpdateSqlInjectionMatchSetResponse = (output, context) => {
5785
- return {
5786
- ChangeToken: __expectString(output.ChangeToken),
5787
- };
5788
- };
5789
- const de_UpdateWebACLResponse = (output, context) => {
5790
- return {
5791
- ChangeToken: __expectString(output.ChangeToken),
5792
- };
5793
- };
5794
- const de_UpdateXssMatchSetResponse = (output, context) => {
5795
- return {
5796
- ChangeToken: __expectString(output.ChangeToken),
5797
- };
5798
- };
5799
- const de_WafAction = (output, context) => {
5800
- return {
5801
- Type: __expectString(output.Type),
5802
- };
5803
- };
5804
- const de_WAFBadRequestException = (output, context) => {
5805
- return {
5806
- message: __expectString(output.message),
5807
- };
5808
- };
5809
- const de_WAFDisallowedNameException = (output, context) => {
5810
- return {
5811
- message: __expectString(output.message),
5812
- };
5813
- };
5814
- const de_WAFEntityMigrationException = (output, context) => {
5815
- return {
5816
- MigrationErrorReason: __expectString(output.MigrationErrorReason),
5817
- MigrationErrorType: __expectString(output.MigrationErrorType),
5818
- message: __expectString(output.message),
5819
- };
5820
- };
5821
- const de_WAFInternalErrorException = (output, context) => {
5822
- return {
5823
- message: __expectString(output.message),
5824
- };
5825
- };
5826
- const de_WAFInvalidAccountException = (output, context) => {
5827
- return {};
5828
- };
5829
- const de_WAFInvalidOperationException = (output, context) => {
5830
- return {
5831
- message: __expectString(output.message),
5832
- };
5833
- };
5834
- const de_WAFInvalidParameterException = (output, context) => {
5835
- return {
5836
- field: __expectString(output.field),
5837
- parameter: __expectString(output.parameter),
5838
- reason: __expectString(output.reason),
5839
- };
5840
- };
5841
- const de_WAFInvalidPermissionPolicyException = (output, context) => {
5842
- return {
5843
- message: __expectString(output.message),
5844
- };
5845
- };
5846
- const de_WAFInvalidRegexPatternException = (output, context) => {
5847
- return {
5848
- message: __expectString(output.message),
5849
- };
5850
- };
5851
- const de_WAFLimitsExceededException = (output, context) => {
5852
- return {
5853
- message: __expectString(output.message),
5854
- };
5855
- };
5856
- const de_WAFNonEmptyEntityException = (output, context) => {
5857
- return {
5858
- message: __expectString(output.message),
5859
- };
5860
- };
5861
- const de_WAFNonexistentContainerException = (output, context) => {
5862
- return {
5863
- message: __expectString(output.message),
5864
- };
5865
- };
5866
- const de_WAFNonexistentItemException = (output, context) => {
5867
- return {
5868
- message: __expectString(output.message),
5869
- };
5870
- };
5871
- const de_WafOverrideAction = (output, context) => {
5872
- return {
5873
- Type: __expectString(output.Type),
5874
- };
5875
- };
5876
- const de_WAFReferencedItemException = (output, context) => {
5877
- return {
5878
- message: __expectString(output.message),
5879
- };
5880
- };
5881
- const de_WAFServiceLinkedRoleErrorException = (output, context) => {
5882
- return {
5883
- message: __expectString(output.message),
5884
- };
5885
- };
5886
- const de_WAFStaleDataException = (output, context) => {
5887
- return {
5888
- message: __expectString(output.message),
5889
- };
5890
- };
5891
- const de_WAFSubscriptionNotFoundException = (output, context) => {
5892
- return {
5893
- message: __expectString(output.message),
5894
- };
5895
- };
5896
- const de_WAFTagOperationException = (output, context) => {
5897
- return {
5898
- message: __expectString(output.message),
5899
- };
5900
- };
5901
- const de_WAFTagOperationInternalErrorException = (output, context) => {
5902
- return {
5903
- message: __expectString(output.message),
5904
- };
5905
- };
5906
- const de_WebACL = (output, context) => {
5907
- return {
5908
- DefaultAction: output.DefaultAction != null ? de_WafAction(output.DefaultAction, context) : undefined,
5909
- MetricName: __expectString(output.MetricName),
5910
- Name: __expectString(output.Name),
5911
- Rules: output.Rules != null ? de_ActivatedRules(output.Rules, context) : undefined,
5912
- WebACLArn: __expectString(output.WebACLArn),
5913
- WebACLId: __expectString(output.WebACLId),
5914
- };
5915
- };
5916
- const de_WebACLSummaries = (output, context) => {
5917
- const retVal = (output || [])
5918
- .filter((e) => e != null)
5919
- .map((entry) => {
5920
- if (entry === null) {
5921
- return null;
5922
- }
5923
- return de_WebACLSummary(entry, context);
4079
+ const de_SampledHTTPRequest = (output, context) => {
4080
+ return take(output, {
4081
+ Action: __expectString,
4082
+ Request: _json,
4083
+ RuleWithinRuleGroup: __expectString,
4084
+ Timestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
4085
+ Weight: __expectLong,
5924
4086
  });
5925
- return retVal;
5926
- };
5927
- const de_WebACLSummary = (output, context) => {
5928
- return {
5929
- Name: __expectString(output.Name),
5930
- WebACLId: __expectString(output.WebACLId),
5931
- };
5932
- };
5933
- const de_XssMatchSet = (output, context) => {
5934
- return {
5935
- Name: __expectString(output.Name),
5936
- XssMatchSetId: __expectString(output.XssMatchSetId),
5937
- XssMatchTuples: output.XssMatchTuples != null ? de_XssMatchTuples(output.XssMatchTuples, context) : undefined,
5938
- };
5939
4087
  };
5940
- const de_XssMatchSetSummaries = (output, context) => {
4088
+ const de_SampledHTTPRequests = (output, context) => {
5941
4089
  const retVal = (output || [])
5942
4090
  .filter((e) => e != null)
5943
4091
  .map((entry) => {
5944
- if (entry === null) {
5945
- return null;
5946
- }
5947
- return de_XssMatchSetSummary(entry, context);
4092
+ return de_SampledHTTPRequest(entry, context);
5948
4093
  });
5949
4094
  return retVal;
5950
4095
  };
5951
- const de_XssMatchSetSummary = (output, context) => {
5952
- return {
5953
- Name: __expectString(output.Name),
5954
- XssMatchSetId: __expectString(output.XssMatchSetId),
5955
- };
5956
- };
5957
- const de_XssMatchTuple = (output, context) => {
5958
- return {
5959
- FieldToMatch: output.FieldToMatch != null ? de_FieldToMatch(output.FieldToMatch, context) : undefined,
5960
- TextTransformation: __expectString(output.TextTransformation),
5961
- };
5962
- };
5963
- const de_XssMatchTuples = (output, context) => {
5964
- const retVal = (output || [])
5965
- .filter((e) => e != null)
5966
- .map((entry) => {
5967
- if (entry === null) {
5968
- return null;
5969
- }
5970
- return de_XssMatchTuple(entry, context);
4096
+ const de_TimeWindow = (output, context) => {
4097
+ return take(output, {
4098
+ EndTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
4099
+ StartTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
5971
4100
  });
5972
- return retVal;
5973
4101
  };
5974
4102
  const deserializeMetadata = (output) => ({
5975
4103
  httpStatusCode: output.statusCode,
@@ -5984,6 +4112,7 @@ const collectBody = (streamBody = new Uint8Array(), context) => {
5984
4112
  return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
5985
4113
  };
5986
4114
  const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
4115
+ const throwDefaultError = withBaseException(__BaseException);
5987
4116
  const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
5988
4117
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
5989
4118
  const contents = {