@aws-sdk/client-waf-regional 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 +406 -2335
  2. package/dist-es/protocols/Aws_json1_1.js +407 -2336
  3. package/package.json +6 -6
package/dist-es/protocols/Aws_json1_1.js CHANGED
@@ -1,257 +1,257 @@
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, WAFUnavailableEntityException, } from "../models/models_0";
4
4
  import { WAFRegionalServiceException as __BaseException } from "../models/WAFRegionalServiceException";
5
5
  export const se_AssociateWebACLCommand = async (input, context) => {
6
6
  const headers = sharedHeaders("AssociateWebACL");
7
7
  let body;
8
- body = JSON.stringify(se_AssociateWebACLRequest(input, context));
8
+ body = JSON.stringify(_json(input));
9
9
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
10
10
  };
11
11
  export const se_CreateByteMatchSetCommand = async (input, context) => {
12
12
  const headers = sharedHeaders("CreateByteMatchSet");
13
13
  let body;
14
- body = JSON.stringify(se_CreateByteMatchSetRequest(input, context));
14
+ body = JSON.stringify(_json(input));
15
15
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
16
16
  };
17
17
  export const se_CreateGeoMatchSetCommand = async (input, context) => {
18
18
  const headers = sharedHeaders("CreateGeoMatchSet");
19
19
  let body;
20
- body = JSON.stringify(se_CreateGeoMatchSetRequest(input, context));
20
+ body = JSON.stringify(_json(input));
21
21
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
22
22
  };
23
23
  export const se_CreateIPSetCommand = async (input, context) => {
24
24
  const headers = sharedHeaders("CreateIPSet");
25
25
  let body;
26
- body = JSON.stringify(se_CreateIPSetRequest(input, context));
26
+ body = JSON.stringify(_json(input));
27
27
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
28
28
  };
29
29
  export const se_CreateRateBasedRuleCommand = async (input, context) => {
30
30
  const headers = sharedHeaders("CreateRateBasedRule");
31
31
  let body;
32
- body = JSON.stringify(se_CreateRateBasedRuleRequest(input, context));
32
+ body = JSON.stringify(_json(input));
33
33
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
34
34
  };
35
35
  export const se_CreateRegexMatchSetCommand = async (input, context) => {
36
36
  const headers = sharedHeaders("CreateRegexMatchSet");
37
37
  let body;
38
- body = JSON.stringify(se_CreateRegexMatchSetRequest(input, context));
38
+ body = JSON.stringify(_json(input));
39
39
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
40
40
  };
41
41
  export const se_CreateRegexPatternSetCommand = async (input, context) => {
42
42
  const headers = sharedHeaders("CreateRegexPatternSet");
43
43
  let body;
44
- body = JSON.stringify(se_CreateRegexPatternSetRequest(input, context));
44
+ body = JSON.stringify(_json(input));
45
45
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
46
46
  };
47
47
  export const se_CreateRuleCommand = async (input, context) => {
48
48
  const headers = sharedHeaders("CreateRule");
49
49
  let body;
50
- body = JSON.stringify(se_CreateRuleRequest(input, context));
50
+ body = JSON.stringify(_json(input));
51
51
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
52
52
  };
53
53
  export const se_CreateRuleGroupCommand = async (input, context) => {
54
54
  const headers = sharedHeaders("CreateRuleGroup");
55
55
  let body;
56
- body = JSON.stringify(se_CreateRuleGroupRequest(input, context));
56
+ body = JSON.stringify(_json(input));
57
57
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
58
58
  };
59
59
  export const se_CreateSizeConstraintSetCommand = async (input, context) => {
60
60
  const headers = sharedHeaders("CreateSizeConstraintSet");
61
61
  let body;
62
- body = JSON.stringify(se_CreateSizeConstraintSetRequest(input, context));
62
+ body = JSON.stringify(_json(input));
63
63
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
64
64
  };
65
65
  export const se_CreateSqlInjectionMatchSetCommand = async (input, context) => {
66
66
  const headers = sharedHeaders("CreateSqlInjectionMatchSet");
67
67
  let body;
68
- body = JSON.stringify(se_CreateSqlInjectionMatchSetRequest(input, context));
68
+ body = JSON.stringify(_json(input));
69
69
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
70
70
  };
71
71
  export const se_CreateWebACLCommand = async (input, context) => {
72
72
  const headers = sharedHeaders("CreateWebACL");
73
73
  let body;
74
- body = JSON.stringify(se_CreateWebACLRequest(input, context));
74
+ body = JSON.stringify(_json(input));
75
75
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
76
76
  };
77
77
  export const se_CreateWebACLMigrationStackCommand = async (input, context) => {
78
78
  const headers = sharedHeaders("CreateWebACLMigrationStack");
79
79
  let body;
80
- body = JSON.stringify(se_CreateWebACLMigrationStackRequest(input, context));
80
+ body = JSON.stringify(_json(input));
81
81
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
82
82
  };
83
83
  export const se_CreateXssMatchSetCommand = async (input, context) => {
84
84
  const headers = sharedHeaders("CreateXssMatchSet");
85
85
  let body;
86
- body = JSON.stringify(se_CreateXssMatchSetRequest(input, context));
86
+ body = JSON.stringify(_json(input));
87
87
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
88
88
  };
89
89
  export const se_DeleteByteMatchSetCommand = async (input, context) => {
90
90
  const headers = sharedHeaders("DeleteByteMatchSet");
91
91
  let body;
92
- body = JSON.stringify(se_DeleteByteMatchSetRequest(input, context));
92
+ body = JSON.stringify(_json(input));
93
93
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
94
94
  };
95
95
  export const se_DeleteGeoMatchSetCommand = async (input, context) => {
96
96
  const headers = sharedHeaders("DeleteGeoMatchSet");
97
97
  let body;
98
- body = JSON.stringify(se_DeleteGeoMatchSetRequest(input, context));
98
+ body = JSON.stringify(_json(input));
99
99
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
100
100
  };
101
101
  export const se_DeleteIPSetCommand = async (input, context) => {
102
102
  const headers = sharedHeaders("DeleteIPSet");
103
103
  let body;
104
- body = JSON.stringify(se_DeleteIPSetRequest(input, context));
104
+ body = JSON.stringify(_json(input));
105
105
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
106
106
  };
107
107
  export const se_DeleteLoggingConfigurationCommand = async (input, context) => {
108
108
  const headers = sharedHeaders("DeleteLoggingConfiguration");
109
109
  let body;
110
- body = JSON.stringify(se_DeleteLoggingConfigurationRequest(input, context));
110
+ body = JSON.stringify(_json(input));
111
111
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
112
112
  };
113
113
  export const se_DeletePermissionPolicyCommand = async (input, context) => {
114
114
  const headers = sharedHeaders("DeletePermissionPolicy");
115
115
  let body;
116
- body = JSON.stringify(se_DeletePermissionPolicyRequest(input, context));
116
+ body = JSON.stringify(_json(input));
117
117
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
118
118
  };
119
119
  export const se_DeleteRateBasedRuleCommand = async (input, context) => {
120
120
  const headers = sharedHeaders("DeleteRateBasedRule");
121
121
  let body;
122
- body = JSON.stringify(se_DeleteRateBasedRuleRequest(input, context));
122
+ body = JSON.stringify(_json(input));
123
123
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
124
124
  };
125
125
  export const se_DeleteRegexMatchSetCommand = async (input, context) => {
126
126
  const headers = sharedHeaders("DeleteRegexMatchSet");
127
127
  let body;
128
- body = JSON.stringify(se_DeleteRegexMatchSetRequest(input, context));
128
+ body = JSON.stringify(_json(input));
129
129
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
130
130
  };
131
131
  export const se_DeleteRegexPatternSetCommand = async (input, context) => {
132
132
  const headers = sharedHeaders("DeleteRegexPatternSet");
133
133
  let body;
134
- body = JSON.stringify(se_DeleteRegexPatternSetRequest(input, context));
134
+ body = JSON.stringify(_json(input));
135
135
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
136
136
  };
137
137
  export const se_DeleteRuleCommand = async (input, context) => {
138
138
  const headers = sharedHeaders("DeleteRule");
139
139
  let body;
140
- body = JSON.stringify(se_DeleteRuleRequest(input, context));
140
+ body = JSON.stringify(_json(input));
141
141
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
142
142
  };
143
143
  export const se_DeleteRuleGroupCommand = async (input, context) => {
144
144
  const headers = sharedHeaders("DeleteRuleGroup");
145
145
  let body;
146
- body = JSON.stringify(se_DeleteRuleGroupRequest(input, context));
146
+ body = JSON.stringify(_json(input));
147
147
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
148
148
  };
149
149
  export const se_DeleteSizeConstraintSetCommand = async (input, context) => {
150
150
  const headers = sharedHeaders("DeleteSizeConstraintSet");
151
151
  let body;
152
- body = JSON.stringify(se_DeleteSizeConstraintSetRequest(input, context));
152
+ body = JSON.stringify(_json(input));
153
153
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
154
154
  };
155
155
  export const se_DeleteSqlInjectionMatchSetCommand = async (input, context) => {
156
156
  const headers = sharedHeaders("DeleteSqlInjectionMatchSet");
157
157
  let body;
158
- body = JSON.stringify(se_DeleteSqlInjectionMatchSetRequest(input, context));
158
+ body = JSON.stringify(_json(input));
159
159
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
160
160
  };
161
161
  export const se_DeleteWebACLCommand = async (input, context) => {
162
162
  const headers = sharedHeaders("DeleteWebACL");
163
163
  let body;
164
- body = JSON.stringify(se_DeleteWebACLRequest(input, context));
164
+ body = JSON.stringify(_json(input));
165
165
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
166
166
  };
167
167
  export const se_DeleteXssMatchSetCommand = async (input, context) => {
168
168
  const headers = sharedHeaders("DeleteXssMatchSet");
169
169
  let body;
170
- body = JSON.stringify(se_DeleteXssMatchSetRequest(input, context));
170
+ body = JSON.stringify(_json(input));
171
171
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
172
172
  };
173
173
  export const se_DisassociateWebACLCommand = async (input, context) => {
174
174
  const headers = sharedHeaders("DisassociateWebACL");
175
175
  let body;
176
- body = JSON.stringify(se_DisassociateWebACLRequest(input, context));
176
+ body = JSON.stringify(_json(input));
177
177
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
178
178
  };
179
179
  export const se_GetByteMatchSetCommand = async (input, context) => {
180
180
  const headers = sharedHeaders("GetByteMatchSet");
181
181
  let body;
182
- body = JSON.stringify(se_GetByteMatchSetRequest(input, context));
182
+ body = JSON.stringify(_json(input));
183
183
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
184
184
  };
185
185
  export const se_GetChangeTokenCommand = async (input, context) => {
186
186
  const headers = sharedHeaders("GetChangeToken");
187
187
  let body;
188
- body = JSON.stringify(se_GetChangeTokenRequest(input, context));
188
+ body = JSON.stringify(_json(input));
189
189
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
190
190
  };
191
191
  export const se_GetChangeTokenStatusCommand = async (input, context) => {
192
192
  const headers = sharedHeaders("GetChangeTokenStatus");
193
193
  let body;
194
- body = JSON.stringify(se_GetChangeTokenStatusRequest(input, context));
194
+ body = JSON.stringify(_json(input));
195
195
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
196
196
  };
197
197
  export const se_GetGeoMatchSetCommand = async (input, context) => {
198
198
  const headers = sharedHeaders("GetGeoMatchSet");
199
199
  let body;
200
- body = JSON.stringify(se_GetGeoMatchSetRequest(input, context));
200
+ body = JSON.stringify(_json(input));
201
201
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
202
202
  };
203
203
  export const se_GetIPSetCommand = async (input, context) => {
204
204
  const headers = sharedHeaders("GetIPSet");
205
205
  let body;
206
- body = JSON.stringify(se_GetIPSetRequest(input, context));
206
+ body = JSON.stringify(_json(input));
207
207
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
208
208
  };
209
209
  export const se_GetLoggingConfigurationCommand = async (input, context) => {
210
210
  const headers = sharedHeaders("GetLoggingConfiguration");
211
211
  let body;
212
- body = JSON.stringify(se_GetLoggingConfigurationRequest(input, context));
212
+ body = JSON.stringify(_json(input));
213
213
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
214
214
  };
215
215
  export const se_GetPermissionPolicyCommand = async (input, context) => {
216
216
  const headers = sharedHeaders("GetPermissionPolicy");
217
217
  let body;
218
- body = JSON.stringify(se_GetPermissionPolicyRequest(input, context));
218
+ body = JSON.stringify(_json(input));
219
219
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
220
220
  };
221
221
  export const se_GetRateBasedRuleCommand = async (input, context) => {
222
222
  const headers = sharedHeaders("GetRateBasedRule");
223
223
  let body;
224
- body = JSON.stringify(se_GetRateBasedRuleRequest(input, context));
224
+ body = JSON.stringify(_json(input));
225
225
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
226
226
  };
227
227
  export const se_GetRateBasedRuleManagedKeysCommand = async (input, context) => {
228
228
  const headers = sharedHeaders("GetRateBasedRuleManagedKeys");
229
229
  let body;
230
- body = JSON.stringify(se_GetRateBasedRuleManagedKeysRequest(input, context));
230
+ body = JSON.stringify(_json(input));
231
231
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
232
232
  };
233
233
  export const se_GetRegexMatchSetCommand = async (input, context) => {
234
234
  const headers = sharedHeaders("GetRegexMatchSet");
235
235
  let body;
236
- body = JSON.stringify(se_GetRegexMatchSetRequest(input, context));
236
+ body = JSON.stringify(_json(input));
237
237
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
238
238
  };
239
239
  export const se_GetRegexPatternSetCommand = async (input, context) => {
240
240
  const headers = sharedHeaders("GetRegexPatternSet");
241
241
  let body;
242
- body = JSON.stringify(se_GetRegexPatternSetRequest(input, context));
242
+ body = JSON.stringify(_json(input));
243
243
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
244
244
  };
245
245
  export const se_GetRuleCommand = async (input, context) => {
246
246
  const headers = sharedHeaders("GetRule");
247
247
  let body;
248
- body = JSON.stringify(se_GetRuleRequest(input, context));
248
+ body = JSON.stringify(_json(input));
249
249
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
250
250
  };
251
251
  export const se_GetRuleGroupCommand = async (input, context) => {
252
252
  const headers = sharedHeaders("GetRuleGroup");
253
253
  let body;
254
- body = JSON.stringify(se_GetRuleGroupRequest(input, context));
254
+ body = JSON.stringify(_json(input));
255
255
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
256
256
  };
257
257
  export const se_GetSampledRequestsCommand = async (input, context) => {
@@ -263,157 +263,157 @@ export const se_GetSampledRequestsCommand = async (input, context) => {
263
263
  export const se_GetSizeConstraintSetCommand = async (input, context) => {
264
264
  const headers = sharedHeaders("GetSizeConstraintSet");
265
265
  let body;
266
- body = JSON.stringify(se_GetSizeConstraintSetRequest(input, context));
266
+ body = JSON.stringify(_json(input));
267
267
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
268
268
  };
269
269
  export const se_GetSqlInjectionMatchSetCommand = async (input, context) => {
270
270
  const headers = sharedHeaders("GetSqlInjectionMatchSet");
271
271
  let body;
272
- body = JSON.stringify(se_GetSqlInjectionMatchSetRequest(input, context));
272
+ body = JSON.stringify(_json(input));
273
273
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
274
274
  };
275
275
  export const se_GetWebACLCommand = async (input, context) => {
276
276
  const headers = sharedHeaders("GetWebACL");
277
277
  let body;
278
- body = JSON.stringify(se_GetWebACLRequest(input, context));
278
+ body = JSON.stringify(_json(input));
279
279
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
280
280
  };
281
281
  export const se_GetWebACLForResourceCommand = async (input, context) => {
282
282
  const headers = sharedHeaders("GetWebACLForResource");
283
283
  let body;
284
- body = JSON.stringify(se_GetWebACLForResourceRequest(input, context));
284
+ body = JSON.stringify(_json(input));
285
285
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
286
286
  };
287
287
  export const se_GetXssMatchSetCommand = async (input, context) => {
288
288
  const headers = sharedHeaders("GetXssMatchSet");
289
289
  let body;
290
- body = JSON.stringify(se_GetXssMatchSetRequest(input, context));
290
+ body = JSON.stringify(_json(input));
291
291
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
292
292
  };
293
293
  export const se_ListActivatedRulesInRuleGroupCommand = async (input, context) => {
294
294
  const headers = sharedHeaders("ListActivatedRulesInRuleGroup");
295
295
  let body;
296
- body = JSON.stringify(se_ListActivatedRulesInRuleGroupRequest(input, context));
296
+ body = JSON.stringify(_json(input));
297
297
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
298
298
  };
299
299
  export const se_ListByteMatchSetsCommand = async (input, context) => {
300
300
  const headers = sharedHeaders("ListByteMatchSets");
301
301
  let body;
302
- body = JSON.stringify(se_ListByteMatchSetsRequest(input, context));
302
+ body = JSON.stringify(_json(input));
303
303
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
304
304
  };
305
305
  export const se_ListGeoMatchSetsCommand = async (input, context) => {
306
306
  const headers = sharedHeaders("ListGeoMatchSets");
307
307
  let body;
308
- body = JSON.stringify(se_ListGeoMatchSetsRequest(input, context));
308
+ body = JSON.stringify(_json(input));
309
309
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
310
310
  };
311
311
  export const se_ListIPSetsCommand = async (input, context) => {
312
312
  const headers = sharedHeaders("ListIPSets");
313
313
  let body;
314
- body = JSON.stringify(se_ListIPSetsRequest(input, context));
314
+ body = JSON.stringify(_json(input));
315
315
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
316
316
  };
317
317
  export const se_ListLoggingConfigurationsCommand = async (input, context) => {
318
318
  const headers = sharedHeaders("ListLoggingConfigurations");
319
319
  let body;
320
- body = JSON.stringify(se_ListLoggingConfigurationsRequest(input, context));
320
+ body = JSON.stringify(_json(input));
321
321
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
322
322
  };
323
323
  export const se_ListRateBasedRulesCommand = async (input, context) => {
324
324
  const headers = sharedHeaders("ListRateBasedRules");
325
325
  let body;
326
- body = JSON.stringify(se_ListRateBasedRulesRequest(input, context));
326
+ body = JSON.stringify(_json(input));
327
327
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
328
328
  };
329
329
  export const se_ListRegexMatchSetsCommand = async (input, context) => {
330
330
  const headers = sharedHeaders("ListRegexMatchSets");
331
331
  let body;
332
- body = JSON.stringify(se_ListRegexMatchSetsRequest(input, context));
332
+ body = JSON.stringify(_json(input));
333
333
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
334
334
  };
335
335
  export const se_ListRegexPatternSetsCommand = async (input, context) => {
336
336
  const headers = sharedHeaders("ListRegexPatternSets");
337
337
  let body;
338
- body = JSON.stringify(se_ListRegexPatternSetsRequest(input, context));
338
+ body = JSON.stringify(_json(input));
339
339
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
340
340
  };
341
341
  export const se_ListResourcesForWebACLCommand = async (input, context) => {
342
342
  const headers = sharedHeaders("ListResourcesForWebACL");
343
343
  let body;
344
- body = JSON.stringify(se_ListResourcesForWebACLRequest(input, context));
344
+ body = JSON.stringify(_json(input));
345
345
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
346
346
  };
347
347
  export const se_ListRuleGroupsCommand = async (input, context) => {
348
348
  const headers = sharedHeaders("ListRuleGroups");
349
349
  let body;
350
- body = JSON.stringify(se_ListRuleGroupsRequest(input, context));
350
+ body = JSON.stringify(_json(input));
351
351
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
352
352
  };
353
353
  export const se_ListRulesCommand = async (input, context) => {
354
354
  const headers = sharedHeaders("ListRules");
355
355
  let body;
356
- body = JSON.stringify(se_ListRulesRequest(input, context));
356
+ body = JSON.stringify(_json(input));
357
357
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
358
358
  };
359
359
  export const se_ListSizeConstraintSetsCommand = async (input, context) => {
360
360
  const headers = sharedHeaders("ListSizeConstraintSets");
361
361
  let body;
362
- body = JSON.stringify(se_ListSizeConstraintSetsRequest(input, context));
362
+ body = JSON.stringify(_json(input));
363
363
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
364
364
  };
365
365
  export const se_ListSqlInjectionMatchSetsCommand = async (input, context) => {
366
366
  const headers = sharedHeaders("ListSqlInjectionMatchSets");
367
367
  let body;
368
- body = JSON.stringify(se_ListSqlInjectionMatchSetsRequest(input, context));
368
+ body = JSON.stringify(_json(input));
369
369
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
370
370
  };
371
371
  export const se_ListSubscribedRuleGroupsCommand = async (input, context) => {
372
372
  const headers = sharedHeaders("ListSubscribedRuleGroups");
373
373
  let body;
374
- body = JSON.stringify(se_ListSubscribedRuleGroupsRequest(input, context));
374
+ body = JSON.stringify(_json(input));
375
375
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
376
376
  };
377
377
  export const se_ListTagsForResourceCommand = async (input, context) => {
378
378
  const headers = sharedHeaders("ListTagsForResource");
379
379
  let body;
380
- body = JSON.stringify(se_ListTagsForResourceRequest(input, context));
380
+ body = JSON.stringify(_json(input));
381
381
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
382
382
  };
383
383
  export const se_ListWebACLsCommand = async (input, context) => {
384
384
  const headers = sharedHeaders("ListWebACLs");
385
385
  let body;
386
- body = JSON.stringify(se_ListWebACLsRequest(input, context));
386
+ body = JSON.stringify(_json(input));
387
387
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
388
388
  };
389
389
  export const se_ListXssMatchSetsCommand = async (input, context) => {
390
390
  const headers = sharedHeaders("ListXssMatchSets");
391
391
  let body;
392
- body = JSON.stringify(se_ListXssMatchSetsRequest(input, context));
392
+ body = JSON.stringify(_json(input));
393
393
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
394
394
  };
395
395
  export const se_PutLoggingConfigurationCommand = async (input, context) => {
396
396
  const headers = sharedHeaders("PutLoggingConfiguration");
397
397
  let body;
398
- body = JSON.stringify(se_PutLoggingConfigurationRequest(input, context));
398
+ body = JSON.stringify(_json(input));
399
399
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
400
400
  };
401
401
  export const se_PutPermissionPolicyCommand = async (input, context) => {
402
402
  const headers = sharedHeaders("PutPermissionPolicy");
403
403
  let body;
404
- body = JSON.stringify(se_PutPermissionPolicyRequest(input, context));
404
+ body = JSON.stringify(_json(input));
405
405
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
406
406
  };
407
407
  export const se_TagResourceCommand = async (input, context) => {
408
408
  const headers = sharedHeaders("TagResource");
409
409
  let body;
410
- body = JSON.stringify(se_TagResourceRequest(input, context));
410
+ body = JSON.stringify(_json(input));
411
411
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
412
412
  };
413
413
  export const se_UntagResourceCommand = async (input, context) => {
414
414
  const headers = sharedHeaders("UntagResource");
415
415
  let body;
416
- body = JSON.stringify(se_UntagResourceRequest(input, context));
416
+ body = JSON.stringify(_json(input));
417
417
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
418
418
  };
419
419
  export const se_UpdateByteMatchSetCommand = async (input, context) => {
@@ -425,67 +425,67 @@ export const se_UpdateByteMatchSetCommand = async (input, context) => {
425
425
  export const se_UpdateGeoMatchSetCommand = async (input, context) => {
426
426
  const headers = sharedHeaders("UpdateGeoMatchSet");
427
427
  let body;
428
- body = JSON.stringify(se_UpdateGeoMatchSetRequest(input, context));
428
+ body = JSON.stringify(_json(input));
429
429
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
430
430
  };
431
431
  export const se_UpdateIPSetCommand = async (input, context) => {
432
432
  const headers = sharedHeaders("UpdateIPSet");
433
433
  let body;
434
- body = JSON.stringify(se_UpdateIPSetRequest(input, context));
434
+ body = JSON.stringify(_json(input));
435
435
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
436
436
  };
437
437
  export const se_UpdateRateBasedRuleCommand = async (input, context) => {
438
438
  const headers = sharedHeaders("UpdateRateBasedRule");
439
439
  let body;
440
- body = JSON.stringify(se_UpdateRateBasedRuleRequest(input, context));
440
+ body = JSON.stringify(_json(input));
441
441
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
442
442
  };
443
443
  export const se_UpdateRegexMatchSetCommand = async (input, context) => {
444
444
  const headers = sharedHeaders("UpdateRegexMatchSet");
445
445
  let body;
446
- body = JSON.stringify(se_UpdateRegexMatchSetRequest(input, context));
446
+ body = JSON.stringify(_json(input));
447
447
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
448
448
  };
449
449
  export const se_UpdateRegexPatternSetCommand = async (input, context) => {
450
450
  const headers = sharedHeaders("UpdateRegexPatternSet");
451
451
  let body;
452
- body = JSON.stringify(se_UpdateRegexPatternSetRequest(input, context));
452
+ body = JSON.stringify(_json(input));
453
453
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
454
454
  };
455
455
  export const se_UpdateRuleCommand = async (input, context) => {
456
456
  const headers = sharedHeaders("UpdateRule");
457
457
  let body;
458
- body = JSON.stringify(se_UpdateRuleRequest(input, context));
458
+ body = JSON.stringify(_json(input));
459
459
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
460
460
  };
461
461
  export const se_UpdateRuleGroupCommand = async (input, context) => {
462
462
  const headers = sharedHeaders("UpdateRuleGroup");
463
463
  let body;
464
- body = JSON.stringify(se_UpdateRuleGroupRequest(input, context));
464
+ body = JSON.stringify(_json(input));
465
465
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
466
466
  };
467
467
  export const se_UpdateSizeConstraintSetCommand = async (input, context) => {
468
468
  const headers = sharedHeaders("UpdateSizeConstraintSet");
469
469
  let body;
470
- body = JSON.stringify(se_UpdateSizeConstraintSetRequest(input, context));
470
+ body = JSON.stringify(_json(input));
471
471
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
472
472
  };
473
473
  export const se_UpdateSqlInjectionMatchSetCommand = async (input, context) => {
474
474
  const headers = sharedHeaders("UpdateSqlInjectionMatchSet");
475
475
  let body;
476
- body = JSON.stringify(se_UpdateSqlInjectionMatchSetRequest(input, context));
476
+ body = JSON.stringify(_json(input));
477
477
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
478
478
  };
479
479
  export const se_UpdateWebACLCommand = async (input, context) => {
480
480
  const headers = sharedHeaders("UpdateWebACL");
481
481
  let body;
482
- body = JSON.stringify(se_UpdateWebACLRequest(input, context));
482
+ body = JSON.stringify(_json(input));
483
483
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
484
484
  };
485
485
  export const se_UpdateXssMatchSetCommand = async (input, context) => {
486
486
  const headers = sharedHeaders("UpdateXssMatchSet");
487
487
  let body;
488
- body = JSON.stringify(se_UpdateXssMatchSetRequest(input, context));
488
+ body = JSON.stringify(_json(input));
489
489
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
490
490
  };
491
491
  export const de_AssociateWebACLCommand = async (output, context) => {
@@ -494,12 +494,12 @@ export const de_AssociateWebACLCommand = async (output, context) => {
494
494
  }
495
495
  const data = await parseBody(output.body, context);
496
496
  let contents = {};
497
- contents = de_AssociateWebACLResponse(data, context);
497
+ contents = _json(data);
498
498
  const response = {
499
499
  $metadata: deserializeMetadata(output),
500
500
  ...contents,
501
501
  };
502
- return Promise.resolve(response);
502
+ return response;
503
503
  };
504
504
  const de_AssociateWebACLCommandError = async (output, context) => {
505
505
  const parsedOutput = {
@@ -525,10 +525,9 @@ const de_AssociateWebACLCommandError = async (output, context) => {
525
525
  throw await de_WAFUnavailableEntityExceptionRes(parsedOutput, context);
526
526
  default:
527
527
  const parsedBody = parsedOutput.body;
528
- throwDefaultError({
528
+ return throwDefaultError({
529
529
  output,
530
530
  parsedBody,
531
- exceptionCtor: __BaseException,
532
531
  errorCode,
533
532
  });
534
533
  }
@@ -544,7 +543,7 @@ export const de_CreateByteMatchSetCommand = async (output, context) => {
544
543
  $metadata: deserializeMetadata(output),
545
544
  ...contents,
546
545
  };
547
- return Promise.resolve(response);
546
+ return response;
548
547
  };
549
548
  const de_CreateByteMatchSetCommandError = async (output, context) => {
550
549
  const parsedOutput = {
@@ -573,10 +572,9 @@ const de_CreateByteMatchSetCommandError = async (output, context) => {
573
572
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
574
573
  default:
575
574
  const parsedBody = parsedOutput.body;
576
- throwDefaultError({
575
+ return throwDefaultError({
577
576
  output,
578
577
  parsedBody,
579
- exceptionCtor: __BaseException,
580
578
  errorCode,
581
579
  });
582
580
  }
@@ -587,12 +585,12 @@ export const de_CreateGeoMatchSetCommand = async (output, context) => {
587
585
  }
588
586
  const data = await parseBody(output.body, context);
589
587
  let contents = {};
590
- contents = de_CreateGeoMatchSetResponse(data, context);
588
+ contents = _json(data);
591
589
  const response = {
592
590
  $metadata: deserializeMetadata(output),
593
591
  ...contents,
594
592
  };
595
- return Promise.resolve(response);
593
+ return response;
596
594
  };
597
595
  const de_CreateGeoMatchSetCommandError = async (output, context) => {
598
596
  const parsedOutput = {
@@ -621,10 +619,9 @@ const de_CreateGeoMatchSetCommandError = async (output, context) => {
621
619
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
622
620
  default:
623
621
  const parsedBody = parsedOutput.body;
624
- throwDefaultError({
622
+ return throwDefaultError({
625
623
  output,
626
624
  parsedBody,
627
- exceptionCtor: __BaseException,
628
625
  errorCode,
629
626
  });
630
627
  }
@@ -635,12 +632,12 @@ export const de_CreateIPSetCommand = async (output, context) => {
635
632
  }
636
633
  const data = await parseBody(output.body, context);
637
634
  let contents = {};
638
- contents = de_CreateIPSetResponse(data, context);
635
+ contents = _json(data);
639
636
  const response = {
640
637
  $metadata: deserializeMetadata(output),
641
638
  ...contents,
642
639
  };
643
- return Promise.resolve(response);
640
+ return response;
644
641
  };
645
642
  const de_CreateIPSetCommandError = async (output, context) => {
646
643
  const parsedOutput = {
@@ -669,10 +666,9 @@ const de_CreateIPSetCommandError = async (output, context) => {
669
666
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
670
667
  default:
671
668
  const parsedBody = parsedOutput.body;
672
- throwDefaultError({
669
+ return throwDefaultError({
673
670
  output,
674
671
  parsedBody,
675
- exceptionCtor: __BaseException,
676
672
  errorCode,
677
673
  });
678
674
  }
@@ -683,12 +679,12 @@ export const de_CreateRateBasedRuleCommand = async (output, context) => {
683
679
  }
684
680
  const data = await parseBody(output.body, context);
685
681
  let contents = {};
686
- contents = de_CreateRateBasedRuleResponse(data, context);
682
+ contents = _json(data);
687
683
  const response = {
688
684
  $metadata: deserializeMetadata(output),
689
685
  ...contents,
690
686
  };
691
- return Promise.resolve(response);
687
+ return response;
692
688
  };
693
689
  const de_CreateRateBasedRuleCommandError = async (output, context) => {
694
690
  const parsedOutput = {
@@ -723,10 +719,9 @@ const de_CreateRateBasedRuleCommandError = async (output, context) => {
723
719
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
724
720
  default:
725
721
  const parsedBody = parsedOutput.body;
726
- throwDefaultError({
722
+ return throwDefaultError({
727
723
  output,
728
724
  parsedBody,
729
- exceptionCtor: __BaseException,
730
725
  errorCode,
731
726
  });
732
727
  }
@@ -737,12 +732,12 @@ export const de_CreateRegexMatchSetCommand = async (output, context) => {
737
732
  }
738
733
  const data = await parseBody(output.body, context);
739
734
  let contents = {};
740
- contents = de_CreateRegexMatchSetResponse(data, context);
735
+ contents = _json(data);
741
736
  const response = {
742
737
  $metadata: deserializeMetadata(output),
743
738
  ...contents,
744
739
  };
745
- return Promise.resolve(response);
740
+ return response;
746
741
  };
747
742
  const de_CreateRegexMatchSetCommandError = async (output, context) => {
748
743
  const parsedOutput = {
@@ -765,10 +760,9 @@ const de_CreateRegexMatchSetCommandError = async (output, context) => {
765
760
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
766
761
  default:
767
762
  const parsedBody = parsedOutput.body;
768
- throwDefaultError({
763
+ return throwDefaultError({
769
764
  output,
770
765
  parsedBody,
771
- exceptionCtor: __BaseException,
772
766
  errorCode,
773
767
  });
774
768
  }
@@ -779,12 +773,12 @@ export const de_CreateRegexPatternSetCommand = async (output, context) => {
779
773
  }
780
774
  const data = await parseBody(output.body, context);
781
775
  let contents = {};
782
- contents = de_CreateRegexPatternSetResponse(data, context);
776
+ contents = _json(data);
783
777
  const response = {
784
778
  $metadata: deserializeMetadata(output),
785
779
  ...contents,
786
780
  };
787
- return Promise.resolve(response);
781
+ return response;
788
782
  };
789
783
  const de_CreateRegexPatternSetCommandError = async (output, context) => {
790
784
  const parsedOutput = {
@@ -807,10 +801,9 @@ const de_CreateRegexPatternSetCommandError = async (output, context) => {
807
801
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
808
802
  default:
809
803
  const parsedBody = parsedOutput.body;
810
- throwDefaultError({
804
+ return throwDefaultError({
811
805
  output,
812
806
  parsedBody,
813
- exceptionCtor: __BaseException,
814
807
  errorCode,
815
808
  });
816
809
  }
@@ -821,12 +814,12 @@ export const de_CreateRuleCommand = async (output, context) => {
821
814
  }
822
815
  const data = await parseBody(output.body, context);
823
816
  let contents = {};
824
- contents = de_CreateRuleResponse(data, context);
817
+ contents = _json(data);
825
818
  const response = {
826
819
  $metadata: deserializeMetadata(output),
827
820
  ...contents,
828
821
  };
829
- return Promise.resolve(response);
822
+ return response;
830
823
  };
831
824
  const de_CreateRuleCommandError = async (output, context) => {
832
825
  const parsedOutput = {
@@ -861,10 +854,9 @@ const de_CreateRuleCommandError = async (output, context) => {
861
854
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
862
855
  default:
863
856
  const parsedBody = parsedOutput.body;
864
- throwDefaultError({
857
+ return throwDefaultError({
865
858
  output,
866
859
  parsedBody,
867
- exceptionCtor: __BaseException,
868
860
  errorCode,
869
861
  });
870
862
  }
@@ -875,12 +867,12 @@ export const de_CreateRuleGroupCommand = async (output, context) => {
875
867
  }
876
868
  const data = await parseBody(output.body, context);
877
869
  let contents = {};
878
- contents = de_CreateRuleGroupResponse(data, context);
870
+ contents = _json(data);
879
871
  const response = {
880
872
  $metadata: deserializeMetadata(output),
881
873
  ...contents,
882
874
  };
883
- return Promise.resolve(response);
875
+ return response;
884
876
  };
885
877
  const de_CreateRuleGroupCommandError = async (output, context) => {
886
878
  const parsedOutput = {
@@ -912,10 +904,9 @@ const de_CreateRuleGroupCommandError = async (output, context) => {
912
904
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
913
905
  default:
914
906
  const parsedBody = parsedOutput.body;
915
- throwDefaultError({
907
+ return throwDefaultError({
916
908
  output,
917
909
  parsedBody,
918
- exceptionCtor: __BaseException,
919
910
  errorCode,
920
911
  });
921
912
  }
@@ -926,12 +917,12 @@ export const de_CreateSizeConstraintSetCommand = async (output, context) => {
926
917
  }
927
918
  const data = await parseBody(output.body, context);
928
919
  let contents = {};
929
- contents = de_CreateSizeConstraintSetResponse(data, context);
920
+ contents = _json(data);
930
921
  const response = {
931
922
  $metadata: deserializeMetadata(output),
932
923
  ...contents,
933
924
  };
934
- return Promise.resolve(response);
925
+ return response;
935
926
  };
936
927
  const de_CreateSizeConstraintSetCommandError = async (output, context) => {
937
928
  const parsedOutput = {
@@ -960,10 +951,9 @@ const de_CreateSizeConstraintSetCommandError = async (output, context) => {
960
951
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
961
952
  default:
962
953
  const parsedBody = parsedOutput.body;
963
- throwDefaultError({
954
+ return throwDefaultError({
964
955
  output,
965
956
  parsedBody,
966
- exceptionCtor: __BaseException,
967
957
  errorCode,
968
958
  });
969
959
  }
@@ -974,12 +964,12 @@ export const de_CreateSqlInjectionMatchSetCommand = async (output, context) => {
974
964
  }
975
965
  const data = await parseBody(output.body, context);
976
966
  let contents = {};
977
- contents = de_CreateSqlInjectionMatchSetResponse(data, context);
967
+ contents = _json(data);
978
968
  const response = {
979
969
  $metadata: deserializeMetadata(output),
980
970
  ...contents,
981
971
  };
982
- return Promise.resolve(response);
972
+ return response;
983
973
  };
984
974
  const de_CreateSqlInjectionMatchSetCommandError = async (output, context) => {
985
975
  const parsedOutput = {
@@ -1008,10 +998,9 @@ const de_CreateSqlInjectionMatchSetCommandError = async (output, context) => {
1008
998
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1009
999
  default:
1010
1000
  const parsedBody = parsedOutput.body;
1011
- throwDefaultError({
1001
+ return throwDefaultError({
1012
1002
  output,
1013
1003
  parsedBody,
1014
- exceptionCtor: __BaseException,
1015
1004
  errorCode,
1016
1005
  });
1017
1006
  }
@@ -1022,12 +1011,12 @@ export const de_CreateWebACLCommand = async (output, context) => {
1022
1011
  }
1023
1012
  const data = await parseBody(output.body, context);
1024
1013
  let contents = {};
1025
- contents = de_CreateWebACLResponse(data, context);
1014
+ contents = _json(data);
1026
1015
  const response = {
1027
1016
  $metadata: deserializeMetadata(output),
1028
1017
  ...contents,
1029
1018
  };
1030
- return Promise.resolve(response);
1019
+ return response;
1031
1020
  };
1032
1021
  const de_CreateWebACLCommandError = async (output, context) => {
1033
1022
  const parsedOutput = {
@@ -1065,10 +1054,9 @@ const de_CreateWebACLCommandError = async (output, context) => {
1065
1054
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
1066
1055
  default:
1067
1056
  const parsedBody = parsedOutput.body;
1068
- throwDefaultError({
1057
+ return throwDefaultError({
1069
1058
  output,
1070
1059
  parsedBody,
1071
- exceptionCtor: __BaseException,
1072
1060
  errorCode,
1073
1061
  });
1074
1062
  }
@@ -1079,12 +1067,12 @@ export const de_CreateWebACLMigrationStackCommand = async (output, context) => {
1079
1067
  }
1080
1068
  const data = await parseBody(output.body, context);
1081
1069
  let contents = {};
1082
- contents = de_CreateWebACLMigrationStackResponse(data, context);
1070
+ contents = _json(data);
1083
1071
  const response = {
1084
1072
  $metadata: deserializeMetadata(output),
1085
1073
  ...contents,
1086
1074
  };
1087
- return Promise.resolve(response);
1075
+ return response;
1088
1076
  };
1089
1077
  const de_CreateWebACLMigrationStackCommandError = async (output, context) => {
1090
1078
  const parsedOutput = {
@@ -1110,10 +1098,9 @@ const de_CreateWebACLMigrationStackCommandError = async (output, context) => {
1110
1098
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
1111
1099
  default:
1112
1100
  const parsedBody = parsedOutput.body;
1113
- throwDefaultError({
1101
+ return throwDefaultError({
1114
1102
  output,
1115
1103
  parsedBody,
1116
- exceptionCtor: __BaseException,
1117
1104
  errorCode,
1118
1105
  });
1119
1106
  }
@@ -1124,12 +1111,12 @@ export const de_CreateXssMatchSetCommand = async (output, context) => {
1124
1111
  }
1125
1112
  const data = await parseBody(output.body, context);
1126
1113
  let contents = {};
1127
- contents = de_CreateXssMatchSetResponse(data, context);
1114
+ contents = _json(data);
1128
1115
  const response = {
1129
1116
  $metadata: deserializeMetadata(output),
1130
1117
  ...contents,
1131
1118
  };
1132
- return Promise.resolve(response);
1119
+ return response;
1133
1120
  };
1134
1121
  const de_CreateXssMatchSetCommandError = async (output, context) => {
1135
1122
  const parsedOutput = {
@@ -1158,10 +1145,9 @@ const de_CreateXssMatchSetCommandError = async (output, context) => {
1158
1145
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1159
1146
  default:
1160
1147
  const parsedBody = parsedOutput.body;
1161
- throwDefaultError({
1148
+ return throwDefaultError({
1162
1149
  output,
1163
1150
  parsedBody,
1164
- exceptionCtor: __BaseException,
1165
1151
  errorCode,
1166
1152
  });
1167
1153
  }
@@ -1172,12 +1158,12 @@ export const de_DeleteByteMatchSetCommand = async (output, context) => {
1172
1158
  }
1173
1159
  const data = await parseBody(output.body, context);
1174
1160
  let contents = {};
1175
- contents = de_DeleteByteMatchSetResponse(data, context);
1161
+ contents = _json(data);
1176
1162
  const response = {
1177
1163
  $metadata: deserializeMetadata(output),
1178
1164
  ...contents,
1179
1165
  };
1180
- return Promise.resolve(response);
1166
+ return response;
1181
1167
  };
1182
1168
  const de_DeleteByteMatchSetCommandError = async (output, context) => {
1183
1169
  const parsedOutput = {
@@ -1206,10 +1192,9 @@ const de_DeleteByteMatchSetCommandError = async (output, context) => {
1206
1192
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1207
1193
  default:
1208
1194
  const parsedBody = parsedOutput.body;
1209
- throwDefaultError({
1195
+ return throwDefaultError({
1210
1196
  output,
1211
1197
  parsedBody,
1212
- exceptionCtor: __BaseException,
1213
1198
  errorCode,
1214
1199
  });
1215
1200
  }
@@ -1220,12 +1205,12 @@ export const de_DeleteGeoMatchSetCommand = async (output, context) => {
1220
1205
  }
1221
1206
  const data = await parseBody(output.body, context);
1222
1207
  let contents = {};
1223
- contents = de_DeleteGeoMatchSetResponse(data, context);
1208
+ contents = _json(data);
1224
1209
  const response = {
1225
1210
  $metadata: deserializeMetadata(output),
1226
1211
  ...contents,
1227
1212
  };
1228
- return Promise.resolve(response);
1213
+ return response;
1229
1214
  };
1230
1215
  const de_DeleteGeoMatchSetCommandError = async (output, context) => {
1231
1216
  const parsedOutput = {
@@ -1254,10 +1239,9 @@ const de_DeleteGeoMatchSetCommandError = async (output, context) => {
1254
1239
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1255
1240
  default:
1256
1241
  const parsedBody = parsedOutput.body;
1257
- throwDefaultError({
1242
+ return throwDefaultError({
1258
1243
  output,
1259
1244
  parsedBody,
1260
- exceptionCtor: __BaseException,
1261
1245
  errorCode,
1262
1246
  });
1263
1247
  }
@@ -1268,12 +1252,12 @@ export const de_DeleteIPSetCommand = async (output, context) => {
1268
1252
  }
1269
1253
  const data = await parseBody(output.body, context);
1270
1254
  let contents = {};
1271
- contents = de_DeleteIPSetResponse(data, context);
1255
+ contents = _json(data);
1272
1256
  const response = {
1273
1257
  $metadata: deserializeMetadata(output),
1274
1258
  ...contents,
1275
1259
  };
1276
- return Promise.resolve(response);
1260
+ return response;
1277
1261
  };
1278
1262
  const de_DeleteIPSetCommandError = async (output, context) => {
1279
1263
  const parsedOutput = {
@@ -1302,10 +1286,9 @@ const de_DeleteIPSetCommandError = async (output, context) => {
1302
1286
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1303
1287
  default:
1304
1288
  const parsedBody = parsedOutput.body;
1305
- throwDefaultError({
1289
+ return throwDefaultError({
1306
1290
  output,
1307
1291
  parsedBody,
1308
- exceptionCtor: __BaseException,
1309
1292
  errorCode,
1310
1293
  });
1311
1294
  }
@@ -1316,12 +1299,12 @@ export const de_DeleteLoggingConfigurationCommand = async (output, context) => {
1316
1299
  }
1317
1300
  const data = await parseBody(output.body, context);
1318
1301
  let contents = {};
1319
- contents = de_DeleteLoggingConfigurationResponse(data, context);
1302
+ contents = _json(data);
1320
1303
  const response = {
1321
1304
  $metadata: deserializeMetadata(output),
1322
1305
  ...contents,
1323
1306
  };
1324
- return Promise.resolve(response);
1307
+ return response;
1325
1308
  };
1326
1309
  const de_DeleteLoggingConfigurationCommandError = async (output, context) => {
1327
1310
  const parsedOutput = {
@@ -1341,10 +1324,9 @@ const de_DeleteLoggingConfigurationCommandError = async (output, context) => {
1341
1324
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1342
1325
  default:
1343
1326
  const parsedBody = parsedOutput.body;
1344
- throwDefaultError({
1327
+ return throwDefaultError({
1345
1328
  output,
1346
1329
  parsedBody,
1347
- exceptionCtor: __BaseException,
1348
1330
  errorCode,
1349
1331
  });
1350
1332
  }
@@ -1355,12 +1337,12 @@ export const de_DeletePermissionPolicyCommand = async (output, context) => {
1355
1337
  }
1356
1338
  const data = await parseBody(output.body, context);
1357
1339
  let contents = {};
1358
- contents = de_DeletePermissionPolicyResponse(data, context);
1340
+ contents = _json(data);
1359
1341
  const response = {
1360
1342
  $metadata: deserializeMetadata(output),
1361
1343
  ...contents,
1362
1344
  };
1363
- return Promise.resolve(response);
1345
+ return response;
1364
1346
  };
1365
1347
  const de_DeletePermissionPolicyCommandError = async (output, context) => {
1366
1348
  const parsedOutput = {
@@ -1380,10 +1362,9 @@ const de_DeletePermissionPolicyCommandError = async (output, context) => {
1380
1362
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1381
1363
  default:
1382
1364
  const parsedBody = parsedOutput.body;
1383
- throwDefaultError({
1365
+ return throwDefaultError({
1384
1366
  output,
1385
1367
  parsedBody,
1386
- exceptionCtor: __BaseException,
1387
1368
  errorCode,
1388
1369
  });
1389
1370
  }
@@ -1394,12 +1375,12 @@ export const de_DeleteRateBasedRuleCommand = async (output, context) => {
1394
1375
  }
1395
1376
  const data = await parseBody(output.body, context);
1396
1377
  let contents = {};
1397
- contents = de_DeleteRateBasedRuleResponse(data, context);
1378
+ contents = _json(data);
1398
1379
  const response = {
1399
1380
  $metadata: deserializeMetadata(output),
1400
1381
  ...contents,
1401
1382
  };
1402
- return Promise.resolve(response);
1383
+ return response;
1403
1384
  };
1404
1385
  const de_DeleteRateBasedRuleCommandError = async (output, context) => {
1405
1386
  const parsedOutput = {
@@ -1434,10 +1415,9 @@ const de_DeleteRateBasedRuleCommandError = async (output, context) => {
1434
1415
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
1435
1416
  default:
1436
1417
  const parsedBody = parsedOutput.body;
1437
- throwDefaultError({
1418
+ return throwDefaultError({
1438
1419
  output,
1439
1420
  parsedBody,
1440
- exceptionCtor: __BaseException,
1441
1421
  errorCode,
1442
1422
  });
1443
1423
  }
@@ -1448,12 +1428,12 @@ export const de_DeleteRegexMatchSetCommand = async (output, context) => {
1448
1428
  }
1449
1429
  const data = await parseBody(output.body, context);
1450
1430
  let contents = {};
1451
- contents = de_DeleteRegexMatchSetResponse(data, context);
1431
+ contents = _json(data);
1452
1432
  const response = {
1453
1433
  $metadata: deserializeMetadata(output),
1454
1434
  ...contents,
1455
1435
  };
1456
- return Promise.resolve(response);
1436
+ return response;
1457
1437
  };
1458
1438
  const de_DeleteRegexMatchSetCommandError = async (output, context) => {
1459
1439
  const parsedOutput = {
@@ -1482,10 +1462,9 @@ const de_DeleteRegexMatchSetCommandError = async (output, context) => {
1482
1462
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1483
1463
  default:
1484
1464
  const parsedBody = parsedOutput.body;
1485
- throwDefaultError({
1465
+ return throwDefaultError({
1486
1466
  output,
1487
1467
  parsedBody,
1488
- exceptionCtor: __BaseException,
1489
1468
  errorCode,
1490
1469
  });
1491
1470
  }
@@ -1496,12 +1475,12 @@ export const de_DeleteRegexPatternSetCommand = async (output, context) => {
1496
1475
  }
1497
1476
  const data = await parseBody(output.body, context);
1498
1477
  let contents = {};
1499
- contents = de_DeleteRegexPatternSetResponse(data, context);
1478
+ contents = _json(data);
1500
1479
  const response = {
1501
1480
  $metadata: deserializeMetadata(output),
1502
1481
  ...contents,
1503
1482
  };
1504
- return Promise.resolve(response);
1483
+ return response;
1505
1484
  };
1506
1485
  const de_DeleteRegexPatternSetCommandError = async (output, context) => {
1507
1486
  const parsedOutput = {
@@ -1530,10 +1509,9 @@ const de_DeleteRegexPatternSetCommandError = async (output, context) => {
1530
1509
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1531
1510
  default:
1532
1511
  const parsedBody = parsedOutput.body;
1533
- throwDefaultError({
1512
+ return throwDefaultError({
1534
1513
  output,
1535
1514
  parsedBody,
1536
- exceptionCtor: __BaseException,
1537
1515
  errorCode,
1538
1516
  });
1539
1517
  }
@@ -1544,12 +1522,12 @@ export const de_DeleteRuleCommand = async (output, context) => {
1544
1522
  }
1545
1523
  const data = await parseBody(output.body, context);
1546
1524
  let contents = {};
1547
- contents = de_DeleteRuleResponse(data, context);
1525
+ contents = _json(data);
1548
1526
  const response = {
1549
1527
  $metadata: deserializeMetadata(output),
1550
1528
  ...contents,
1551
1529
  };
1552
- return Promise.resolve(response);
1530
+ return response;
1553
1531
  };
1554
1532
  const de_DeleteRuleCommandError = async (output, context) => {
1555
1533
  const parsedOutput = {
@@ -1584,10 +1562,9 @@ const de_DeleteRuleCommandError = async (output, context) => {
1584
1562
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
1585
1563
  default:
1586
1564
  const parsedBody = parsedOutput.body;
1587
- throwDefaultError({
1565
+ return throwDefaultError({
1588
1566
  output,
1589
1567
  parsedBody,
1590
- exceptionCtor: __BaseException,
1591
1568
  errorCode,
1592
1569
  });
1593
1570
  }
@@ -1598,12 +1575,12 @@ export const de_DeleteRuleGroupCommand = async (output, context) => {
1598
1575
  }
1599
1576
  const data = await parseBody(output.body, context);
1600
1577
  let contents = {};
1601
- contents = de_DeleteRuleGroupResponse(data, context);
1578
+ contents = _json(data);
1602
1579
  const response = {
1603
1580
  $metadata: deserializeMetadata(output),
1604
1581
  ...contents,
1605
1582
  };
1606
- return Promise.resolve(response);
1583
+ return response;
1607
1584
  };
1608
1585
  const de_DeleteRuleGroupCommandError = async (output, context) => {
1609
1586
  const parsedOutput = {
@@ -1638,10 +1615,9 @@ const de_DeleteRuleGroupCommandError = async (output, context) => {
1638
1615
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
1639
1616
  default:
1640
1617
  const parsedBody = parsedOutput.body;
1641
- throwDefaultError({
1618
+ return throwDefaultError({
1642
1619
  output,
1643
1620
  parsedBody,
1644
- exceptionCtor: __BaseException,
1645
1621
  errorCode,
1646
1622
  });
1647
1623
  }
@@ -1652,12 +1628,12 @@ export const de_DeleteSizeConstraintSetCommand = async (output, context) => {
1652
1628
  }
1653
1629
  const data = await parseBody(output.body, context);
1654
1630
  let contents = {};
1655
- contents = de_DeleteSizeConstraintSetResponse(data, context);
1631
+ contents = _json(data);
1656
1632
  const response = {
1657
1633
  $metadata: deserializeMetadata(output),
1658
1634
  ...contents,
1659
1635
  };
1660
- return Promise.resolve(response);
1636
+ return response;
1661
1637
  };
1662
1638
  const de_DeleteSizeConstraintSetCommandError = async (output, context) => {
1663
1639
  const parsedOutput = {
@@ -1686,10 +1662,9 @@ const de_DeleteSizeConstraintSetCommandError = async (output, context) => {
1686
1662
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1687
1663
  default:
1688
1664
  const parsedBody = parsedOutput.body;
1689
- throwDefaultError({
1665
+ return throwDefaultError({
1690
1666
  output,
1691
1667
  parsedBody,
1692
- exceptionCtor: __BaseException,
1693
1668
  errorCode,
1694
1669
  });
1695
1670
  }
@@ -1700,12 +1675,12 @@ export const de_DeleteSqlInjectionMatchSetCommand = async (output, context) => {
1700
1675
  }
1701
1676
  const data = await parseBody(output.body, context);
1702
1677
  let contents = {};
1703
- contents = de_DeleteSqlInjectionMatchSetResponse(data, context);
1678
+ contents = _json(data);
1704
1679
  const response = {
1705
1680
  $metadata: deserializeMetadata(output),
1706
1681
  ...contents,
1707
1682
  };
1708
- return Promise.resolve(response);
1683
+ return response;
1709
1684
  };
1710
1685
  const de_DeleteSqlInjectionMatchSetCommandError = async (output, context) => {
1711
1686
  const parsedOutput = {
@@ -1734,10 +1709,9 @@ const de_DeleteSqlInjectionMatchSetCommandError = async (output, context) => {
1734
1709
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1735
1710
  default:
1736
1711
  const parsedBody = parsedOutput.body;
1737
- throwDefaultError({
1712
+ return throwDefaultError({
1738
1713
  output,
1739
1714
  parsedBody,
1740
- exceptionCtor: __BaseException,
1741
1715
  errorCode,
1742
1716
  });
1743
1717
  }
@@ -1748,12 +1722,12 @@ export const de_DeleteWebACLCommand = async (output, context) => {
1748
1722
  }
1749
1723
  const data = await parseBody(output.body, context);
1750
1724
  let contents = {};
1751
- contents = de_DeleteWebACLResponse(data, context);
1725
+ contents = _json(data);
1752
1726
  const response = {
1753
1727
  $metadata: deserializeMetadata(output),
1754
1728
  ...contents,
1755
1729
  };
1756
- return Promise.resolve(response);
1730
+ return response;
1757
1731
  };
1758
1732
  const de_DeleteWebACLCommandError = async (output, context) => {
1759
1733
  const parsedOutput = {
@@ -1788,10 +1762,9 @@ const de_DeleteWebACLCommandError = async (output, context) => {
1788
1762
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
1789
1763
  default:
1790
1764
  const parsedBody = parsedOutput.body;
1791
- throwDefaultError({
1765
+ return throwDefaultError({
1792
1766
  output,
1793
1767
  parsedBody,
1794
- exceptionCtor: __BaseException,
1795
1768
  errorCode,
1796
1769
  });
1797
1770
  }
@@ -1802,12 +1775,12 @@ export const de_DeleteXssMatchSetCommand = async (output, context) => {
1802
1775
  }
1803
1776
  const data = await parseBody(output.body, context);
1804
1777
  let contents = {};
1805
- contents = de_DeleteXssMatchSetResponse(data, context);
1778
+ contents = _json(data);
1806
1779
  const response = {
1807
1780
  $metadata: deserializeMetadata(output),
1808
1781
  ...contents,
1809
1782
  };
1810
- return Promise.resolve(response);
1783
+ return response;
1811
1784
  };
1812
1785
  const de_DeleteXssMatchSetCommandError = async (output, context) => {
1813
1786
  const parsedOutput = {
@@ -1836,10 +1809,9 @@ const de_DeleteXssMatchSetCommandError = async (output, context) => {
1836
1809
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
1837
1810
  default:
1838
1811
  const parsedBody = parsedOutput.body;
1839
- throwDefaultError({
1812
+ return throwDefaultError({
1840
1813
  output,
1841
1814
  parsedBody,
1842
- exceptionCtor: __BaseException,
1843
1815
  errorCode,
1844
1816
  });
1845
1817
  }
@@ -1850,12 +1822,12 @@ export const de_DisassociateWebACLCommand = async (output, context) => {
1850
1822
  }
1851
1823
  const data = await parseBody(output.body, context);
1852
1824
  let contents = {};
1853
- contents = de_DisassociateWebACLResponse(data, context);
1825
+ contents = _json(data);
1854
1826
  const response = {
1855
1827
  $metadata: deserializeMetadata(output),
1856
1828
  ...contents,
1857
1829
  };
1858
- return Promise.resolve(response);
1830
+ return response;
1859
1831
  };
1860
1832
  const de_DisassociateWebACLCommandError = async (output, context) => {
1861
1833
  const parsedOutput = {
@@ -1878,10 +1850,9 @@ const de_DisassociateWebACLCommandError = async (output, context) => {
1878
1850
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
1879
1851
  default:
1880
1852
  const parsedBody = parsedOutput.body;
1881
- throwDefaultError({
1853
+ return throwDefaultError({
1882
1854
  output,
1883
1855
  parsedBody,
1884
- exceptionCtor: __BaseException,
1885
1856
  errorCode,
1886
1857
  });
1887
1858
  }
@@ -1897,7 +1868,7 @@ export const de_GetByteMatchSetCommand = async (output, context) => {
1897
1868
  $metadata: deserializeMetadata(output),
1898
1869
  ...contents,
1899
1870
  };
1900
- return Promise.resolve(response);
1871
+ return response;
1901
1872
  };
1902
1873
  const de_GetByteMatchSetCommandError = async (output, context) => {
1903
1874
  const parsedOutput = {
@@ -1917,10 +1888,9 @@ const de_GetByteMatchSetCommandError = async (output, context) => {
1917
1888
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
1918
1889
  default:
1919
1890
  const parsedBody = parsedOutput.body;
1920
- throwDefaultError({
1891
+ return throwDefaultError({
1921
1892
  output,
1922
1893
  parsedBody,
1923
- exceptionCtor: __BaseException,
1924
1894
  errorCode,
1925
1895
  });
1926
1896
  }
@@ -1931,12 +1901,12 @@ export const de_GetChangeTokenCommand = async (output, context) => {
1931
1901
  }
1932
1902
  const data = await parseBody(output.body, context);
1933
1903
  let contents = {};
1934
- contents = de_GetChangeTokenResponse(data, context);
1904
+ contents = _json(data);
1935
1905
  const response = {
1936
1906
  $metadata: deserializeMetadata(output),
1937
1907
  ...contents,
1938
1908
  };
1939
- return Promise.resolve(response);
1909
+ return response;
1940
1910
  };
1941
1911
  const de_GetChangeTokenCommandError = async (output, context) => {
1942
1912
  const parsedOutput = {
@@ -1950,10 +1920,9 @@ const de_GetChangeTokenCommandError = async (output, context) => {
1950
1920
  throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
1951
1921
  default:
1952
1922
  const parsedBody = parsedOutput.body;
1953
- throwDefaultError({
1923
+ return throwDefaultError({
1954
1924
  output,
1955
1925
  parsedBody,
1956
- exceptionCtor: __BaseException,
1957
1926
  errorCode,
1958
1927
  });
1959
1928
  }
@@ -1964,12 +1933,12 @@ export const de_GetChangeTokenStatusCommand = async (output, context) => {
1964
1933
  }
1965
1934
  const data = await parseBody(output.body, context);
1966
1935
  let contents = {};
1967
- contents = de_GetChangeTokenStatusResponse(data, context);
1936
+ contents = _json(data);
1968
1937
  const response = {
1969
1938
  $metadata: deserializeMetadata(output),
1970
1939
  ...contents,
1971
1940
  };
1972
- return Promise.resolve(response);
1941
+ return response;
1973
1942
  };
1974
1943
  const de_GetChangeTokenStatusCommandError = async (output, context) => {
1975
1944
  const parsedOutput = {
@@ -1986,10 +1955,9 @@ const de_GetChangeTokenStatusCommandError = async (output, context) => {
1986
1955
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
1987
1956
  default:
1988
1957
  const parsedBody = parsedOutput.body;
1989
- throwDefaultError({
1958
+ return throwDefaultError({
1990
1959
  output,
1991
1960
  parsedBody,
1992
- exceptionCtor: __BaseException,
1993
1961
  errorCode,
1994
1962
  });
1995
1963
  }
@@ -2000,12 +1968,12 @@ export const de_GetGeoMatchSetCommand = async (output, context) => {
2000
1968
  }
2001
1969
  const data = await parseBody(output.body, context);
2002
1970
  let contents = {};
2003
- contents = de_GetGeoMatchSetResponse(data, context);
1971
+ contents = _json(data);
2004
1972
  const response = {
2005
1973
  $metadata: deserializeMetadata(output),
2006
1974
  ...contents,
2007
1975
  };
2008
- return Promise.resolve(response);
1976
+ return response;
2009
1977
  };
2010
1978
  const de_GetGeoMatchSetCommandError = async (output, context) => {
2011
1979
  const parsedOutput = {
@@ -2025,10 +1993,9 @@ const de_GetGeoMatchSetCommandError = async (output, context) => {
2025
1993
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2026
1994
  default:
2027
1995
  const parsedBody = parsedOutput.body;
2028
- throwDefaultError({
1996
+ return throwDefaultError({
2029
1997
  output,
2030
1998
  parsedBody,
2031
- exceptionCtor: __BaseException,
2032
1999
  errorCode,
2033
2000
  });
2034
2001
  }
@@ -2039,12 +2006,12 @@ export const de_GetIPSetCommand = async (output, context) => {
2039
2006
  }
2040
2007
  const data = await parseBody(output.body, context);
2041
2008
  let contents = {};
2042
- contents = de_GetIPSetResponse(data, context);
2009
+ contents = _json(data);
2043
2010
  const response = {
2044
2011
  $metadata: deserializeMetadata(output),
2045
2012
  ...contents,
2046
2013
  };
2047
- return Promise.resolve(response);
2014
+ return response;
2048
2015
  };
2049
2016
  const de_GetIPSetCommandError = async (output, context) => {
2050
2017
  const parsedOutput = {
@@ -2064,10 +2031,9 @@ const de_GetIPSetCommandError = async (output, context) => {
2064
2031
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2065
2032
  default:
2066
2033
  const parsedBody = parsedOutput.body;
2067
- throwDefaultError({
2034
+ return throwDefaultError({
2068
2035
  output,
2069
2036
  parsedBody,
2070
- exceptionCtor: __BaseException,
2071
2037
  errorCode,
2072
2038
  });
2073
2039
  }
@@ -2078,12 +2044,12 @@ export const de_GetLoggingConfigurationCommand = async (output, context) => {
2078
2044
  }
2079
2045
  const data = await parseBody(output.body, context);
2080
2046
  let contents = {};
2081
- contents = de_GetLoggingConfigurationResponse(data, context);
2047
+ contents = _json(data);
2082
2048
  const response = {
2083
2049
  $metadata: deserializeMetadata(output),
2084
2050
  ...contents,
2085
2051
  };
2086
- return Promise.resolve(response);
2052
+ return response;
2087
2053
  };
2088
2054
  const de_GetLoggingConfigurationCommandError = async (output, context) => {
2089
2055
  const parsedOutput = {
@@ -2100,10 +2066,9 @@ const de_GetLoggingConfigurationCommandError = async (output, context) => {
2100
2066
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2101
2067
  default:
2102
2068
  const parsedBody = parsedOutput.body;
2103
- throwDefaultError({
2069
+ return throwDefaultError({
2104
2070
  output,
2105
2071
  parsedBody,
2106
- exceptionCtor: __BaseException,
2107
2072
  errorCode,
2108
2073
  });
2109
2074
  }
@@ -2114,12 +2079,12 @@ export const de_GetPermissionPolicyCommand = async (output, context) => {
2114
2079
  }
2115
2080
  const data = await parseBody(output.body, context);
2116
2081
  let contents = {};
2117
- contents = de_GetPermissionPolicyResponse(data, context);
2082
+ contents = _json(data);
2118
2083
  const response = {
2119
2084
  $metadata: deserializeMetadata(output),
2120
2085
  ...contents,
2121
2086
  };
2122
- return Promise.resolve(response);
2087
+ return response;
2123
2088
  };
2124
2089
  const de_GetPermissionPolicyCommandError = async (output, context) => {
2125
2090
  const parsedOutput = {
@@ -2136,10 +2101,9 @@ const de_GetPermissionPolicyCommandError = async (output, context) => {
2136
2101
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2137
2102
  default:
2138
2103
  const parsedBody = parsedOutput.body;
2139
- throwDefaultError({
2104
+ return throwDefaultError({
2140
2105
  output,
2141
2106
  parsedBody,
2142
- exceptionCtor: __BaseException,
2143
2107
  errorCode,
2144
2108
  });
2145
2109
  }
@@ -2150,12 +2114,12 @@ export const de_GetRateBasedRuleCommand = async (output, context) => {
2150
2114
  }
2151
2115
  const data = await parseBody(output.body, context);
2152
2116
  let contents = {};
2153
- contents = de_GetRateBasedRuleResponse(data, context);
2117
+ contents = _json(data);
2154
2118
  const response = {
2155
2119
  $metadata: deserializeMetadata(output),
2156
2120
  ...contents,
2157
2121
  };
2158
- return Promise.resolve(response);
2122
+ return response;
2159
2123
  };
2160
2124
  const de_GetRateBasedRuleCommandError = async (output, context) => {
2161
2125
  const parsedOutput = {
@@ -2175,10 +2139,9 @@ const de_GetRateBasedRuleCommandError = async (output, context) => {
2175
2139
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2176
2140
  default:
2177
2141
  const parsedBody = parsedOutput.body;
2178
- throwDefaultError({
2142
+ return throwDefaultError({
2179
2143
  output,
2180
2144
  parsedBody,
2181
- exceptionCtor: __BaseException,
2182
2145
  errorCode,
2183
2146
  });
2184
2147
  }
@@ -2189,12 +2152,12 @@ export const de_GetRateBasedRuleManagedKeysCommand = async (output, context) =>
2189
2152
  }
2190
2153
  const data = await parseBody(output.body, context);
2191
2154
  let contents = {};
2192
- contents = de_GetRateBasedRuleManagedKeysResponse(data, context);
2155
+ contents = _json(data);
2193
2156
  const response = {
2194
2157
  $metadata: deserializeMetadata(output),
2195
2158
  ...contents,
2196
2159
  };
2197
- return Promise.resolve(response);
2160
+ return response;
2198
2161
  };
2199
2162
  const de_GetRateBasedRuleManagedKeysCommandError = async (output, context) => {
2200
2163
  const parsedOutput = {
@@ -2217,10 +2180,9 @@ const de_GetRateBasedRuleManagedKeysCommandError = async (output, context) => {
2217
2180
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2218
2181
  default:
2219
2182
  const parsedBody = parsedOutput.body;
2220
- throwDefaultError({
2183
+ return throwDefaultError({
2221
2184
  output,
2222
2185
  parsedBody,
2223
- exceptionCtor: __BaseException,
2224
2186
  errorCode,
2225
2187
  });
2226
2188
  }
@@ -2231,12 +2193,12 @@ export const de_GetRegexMatchSetCommand = async (output, context) => {
2231
2193
  }
2232
2194
  const data = await parseBody(output.body, context);
2233
2195
  let contents = {};
2234
- contents = de_GetRegexMatchSetResponse(data, context);
2196
+ contents = _json(data);
2235
2197
  const response = {
2236
2198
  $metadata: deserializeMetadata(output),
2237
2199
  ...contents,
2238
2200
  };
2239
- return Promise.resolve(response);
2201
+ return response;
2240
2202
  };
2241
2203
  const de_GetRegexMatchSetCommandError = async (output, context) => {
2242
2204
  const parsedOutput = {
@@ -2256,10 +2218,9 @@ const de_GetRegexMatchSetCommandError = async (output, context) => {
2256
2218
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2257
2219
  default:
2258
2220
  const parsedBody = parsedOutput.body;
2259
- throwDefaultError({
2221
+ return throwDefaultError({
2260
2222
  output,
2261
2223
  parsedBody,
2262
- exceptionCtor: __BaseException,
2263
2224
  errorCode,
2264
2225
  });
2265
2226
  }
@@ -2270,12 +2231,12 @@ export const de_GetRegexPatternSetCommand = async (output, context) => {
2270
2231
  }
2271
2232
  const data = await parseBody(output.body, context);
2272
2233
  let contents = {};
2273
- contents = de_GetRegexPatternSetResponse(data, context);
2234
+ contents = _json(data);
2274
2235
  const response = {
2275
2236
  $metadata: deserializeMetadata(output),
2276
2237
  ...contents,
2277
2238
  };
2278
- return Promise.resolve(response);
2239
+ return response;
2279
2240
  };
2280
2241
  const de_GetRegexPatternSetCommandError = async (output, context) => {
2281
2242
  const parsedOutput = {
@@ -2295,10 +2256,9 @@ const de_GetRegexPatternSetCommandError = async (output, context) => {
2295
2256
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2296
2257
  default:
2297
2258
  const parsedBody = parsedOutput.body;
2298
- throwDefaultError({
2259
+ return throwDefaultError({
2299
2260
  output,
2300
2261
  parsedBody,
2301
- exceptionCtor: __BaseException,
2302
2262
  errorCode,
2303
2263
  });
2304
2264
  }
@@ -2309,12 +2269,12 @@ export const de_GetRuleCommand = async (output, context) => {
2309
2269
  }
2310
2270
  const data = await parseBody(output.body, context);
2311
2271
  let contents = {};
2312
- contents = de_GetRuleResponse(data, context);
2272
+ contents = _json(data);
2313
2273
  const response = {
2314
2274
  $metadata: deserializeMetadata(output),
2315
2275
  ...contents,
2316
2276
  };
2317
- return Promise.resolve(response);
2277
+ return response;
2318
2278
  };
2319
2279
  const de_GetRuleCommandError = async (output, context) => {
2320
2280
  const parsedOutput = {
@@ -2334,10 +2294,9 @@ const de_GetRuleCommandError = async (output, context) => {
2334
2294
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2335
2295
  default:
2336
2296
  const parsedBody = parsedOutput.body;
2337
- throwDefaultError({
2297
+ return throwDefaultError({
2338
2298
  output,
2339
2299
  parsedBody,
2340
- exceptionCtor: __BaseException,
2341
2300
  errorCode,
2342
2301
  });
2343
2302
  }
@@ -2348,12 +2307,12 @@ export const de_GetRuleGroupCommand = async (output, context) => {
2348
2307
  }
2349
2308
  const data = await parseBody(output.body, context);
2350
2309
  let contents = {};
2351
- contents = de_GetRuleGroupResponse(data, context);
2310
+ contents = _json(data);
2352
2311
  const response = {
2353
2312
  $metadata: deserializeMetadata(output),
2354
2313
  ...contents,
2355
2314
  };
2356
- return Promise.resolve(response);
2315
+ return response;
2357
2316
  };
2358
2317
  const de_GetRuleGroupCommandError = async (output, context) => {
2359
2318
  const parsedOutput = {
@@ -2370,10 +2329,9 @@ const de_GetRuleGroupCommandError = async (output, context) => {
2370
2329
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2371
2330
  default:
2372
2331
  const parsedBody = parsedOutput.body;
2373
- throwDefaultError({
2332
+ return throwDefaultError({
2374
2333
  output,
2375
2334
  parsedBody,
2376
- exceptionCtor: __BaseException,
2377
2335
  errorCode,
2378
2336
  });
2379
2337
  }
@@ -2389,7 +2347,7 @@ export const de_GetSampledRequestsCommand = async (output, context) => {
2389
2347
  $metadata: deserializeMetadata(output),
2390
2348
  ...contents,
2391
2349
  };
2392
- return Promise.resolve(response);
2350
+ return response;
2393
2351
  };
2394
2352
  const de_GetSampledRequestsCommandError = async (output, context) => {
2395
2353
  const parsedOutput = {
@@ -2406,10 +2364,9 @@ const de_GetSampledRequestsCommandError = async (output, context) => {
2406
2364
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2407
2365
  default:
2408
2366
  const parsedBody = parsedOutput.body;
2409
- throwDefaultError({
2367
+ return throwDefaultError({
2410
2368
  output,
2411
2369
  parsedBody,
2412
- exceptionCtor: __BaseException,
2413
2370
  errorCode,
2414
2371
  });
2415
2372
  }
@@ -2420,12 +2377,12 @@ export const de_GetSizeConstraintSetCommand = async (output, context) => {
2420
2377
  }
2421
2378
  const data = await parseBody(output.body, context);
2422
2379
  let contents = {};
2423
- contents = de_GetSizeConstraintSetResponse(data, context);
2380
+ contents = _json(data);
2424
2381
  const response = {
2425
2382
  $metadata: deserializeMetadata(output),
2426
2383
  ...contents,
2427
2384
  };
2428
- return Promise.resolve(response);
2385
+ return response;
2429
2386
  };
2430
2387
  const de_GetSizeConstraintSetCommandError = async (output, context) => {
2431
2388
  const parsedOutput = {
@@ -2445,10 +2402,9 @@ const de_GetSizeConstraintSetCommandError = async (output, context) => {
2445
2402
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2446
2403
  default:
2447
2404
  const parsedBody = parsedOutput.body;
2448
- throwDefaultError({
2405
+ return throwDefaultError({
2449
2406
  output,
2450
2407
  parsedBody,
2451
- exceptionCtor: __BaseException,
2452
2408
  errorCode,
2453
2409
  });
2454
2410
  }
@@ -2459,12 +2415,12 @@ export const de_GetSqlInjectionMatchSetCommand = async (output, context) => {
2459
2415
  }
2460
2416
  const data = await parseBody(output.body, context);
2461
2417
  let contents = {};
2462
- contents = de_GetSqlInjectionMatchSetResponse(data, context);
2418
+ contents = _json(data);
2463
2419
  const response = {
2464
2420
  $metadata: deserializeMetadata(output),
2465
2421
  ...contents,
2466
2422
  };
2467
- return Promise.resolve(response);
2423
+ return response;
2468
2424
  };
2469
2425
  const de_GetSqlInjectionMatchSetCommandError = async (output, context) => {
2470
2426
  const parsedOutput = {
@@ -2484,10 +2440,9 @@ const de_GetSqlInjectionMatchSetCommandError = async (output, context) => {
2484
2440
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2485
2441
  default:
2486
2442
  const parsedBody = parsedOutput.body;
2487
- throwDefaultError({
2443
+ return throwDefaultError({
2488
2444
  output,
2489
2445
  parsedBody,
2490
- exceptionCtor: __BaseException,
2491
2446
  errorCode,
2492
2447
  });
2493
2448
  }
@@ -2498,12 +2453,12 @@ export const de_GetWebACLCommand = async (output, context) => {
2498
2453
  }
2499
2454
  const data = await parseBody(output.body, context);
2500
2455
  let contents = {};
2501
- contents = de_GetWebACLResponse(data, context);
2456
+ contents = _json(data);
2502
2457
  const response = {
2503
2458
  $metadata: deserializeMetadata(output),
2504
2459
  ...contents,
2505
2460
  };
2506
- return Promise.resolve(response);
2461
+ return response;
2507
2462
  };
2508
2463
  const de_GetWebACLCommandError = async (output, context) => {
2509
2464
  const parsedOutput = {
@@ -2523,10 +2478,9 @@ const de_GetWebACLCommandError = async (output, context) => {
2523
2478
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2524
2479
  default:
2525
2480
  const parsedBody = parsedOutput.body;
2526
- throwDefaultError({
2481
+ return throwDefaultError({
2527
2482
  output,
2528
2483
  parsedBody,
2529
- exceptionCtor: __BaseException,
2530
2484
  errorCode,
2531
2485
  });
2532
2486
  }
@@ -2537,12 +2491,12 @@ export const de_GetWebACLForResourceCommand = async (output, context) => {
2537
2491
  }
2538
2492
  const data = await parseBody(output.body, context);
2539
2493
  let contents = {};
2540
- contents = de_GetWebACLForResourceResponse(data, context);
2494
+ contents = _json(data);
2541
2495
  const response = {
2542
2496
  $metadata: deserializeMetadata(output),
2543
2497
  ...contents,
2544
2498
  };
2545
- return Promise.resolve(response);
2499
+ return response;
2546
2500
  };
2547
2501
  const de_GetWebACLForResourceCommandError = async (output, context) => {
2548
2502
  const parsedOutput = {
@@ -2568,10 +2522,9 @@ const de_GetWebACLForResourceCommandError = async (output, context) => {
2568
2522
  throw await de_WAFUnavailableEntityExceptionRes(parsedOutput, context);
2569
2523
  default:
2570
2524
  const parsedBody = parsedOutput.body;
2571
- throwDefaultError({
2525
+ return throwDefaultError({
2572
2526
  output,
2573
2527
  parsedBody,
2574
- exceptionCtor: __BaseException,
2575
2528
  errorCode,
2576
2529
  });
2577
2530
  }
@@ -2582,12 +2535,12 @@ export const de_GetXssMatchSetCommand = async (output, context) => {
2582
2535
  }
2583
2536
  const data = await parseBody(output.body, context);
2584
2537
  let contents = {};
2585
- contents = de_GetXssMatchSetResponse(data, context);
2538
+ contents = _json(data);
2586
2539
  const response = {
2587
2540
  $metadata: deserializeMetadata(output),
2588
2541
  ...contents,
2589
2542
  };
2590
- return Promise.resolve(response);
2543
+ return response;
2591
2544
  };
2592
2545
  const de_GetXssMatchSetCommandError = async (output, context) => {
2593
2546
  const parsedOutput = {
@@ -2607,10 +2560,9 @@ const de_GetXssMatchSetCommandError = async (output, context) => {
2607
2560
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2608
2561
  default:
2609
2562
  const parsedBody = parsedOutput.body;
2610
- throwDefaultError({
2563
+ return throwDefaultError({
2611
2564
  output,
2612
2565
  parsedBody,
2613
- exceptionCtor: __BaseException,
2614
2566
  errorCode,
2615
2567
  });
2616
2568
  }
@@ -2621,12 +2573,12 @@ export const de_ListActivatedRulesInRuleGroupCommand = async (output, context) =
2621
2573
  }
2622
2574
  const data = await parseBody(output.body, context);
2623
2575
  let contents = {};
2624
- contents = de_ListActivatedRulesInRuleGroupResponse(data, context);
2576
+ contents = _json(data);
2625
2577
  const response = {
2626
2578
  $metadata: deserializeMetadata(output),
2627
2579
  ...contents,
2628
2580
  };
2629
- return Promise.resolve(response);
2581
+ return response;
2630
2582
  };
2631
2583
  const de_ListActivatedRulesInRuleGroupCommandError = async (output, context) => {
2632
2584
  const parsedOutput = {
@@ -2646,10 +2598,9 @@ const de_ListActivatedRulesInRuleGroupCommandError = async (output, context) =>
2646
2598
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2647
2599
  default:
2648
2600
  const parsedBody = parsedOutput.body;
2649
- throwDefaultError({
2601
+ return throwDefaultError({
2650
2602
  output,
2651
2603
  parsedBody,
2652
- exceptionCtor: __BaseException,
2653
2604
  errorCode,
2654
2605
  });
2655
2606
  }
@@ -2660,12 +2611,12 @@ export const de_ListByteMatchSetsCommand = async (output, context) => {
2660
2611
  }
2661
2612
  const data = await parseBody(output.body, context);
2662
2613
  let contents = {};
2663
- contents = de_ListByteMatchSetsResponse(data, context);
2614
+ contents = _json(data);
2664
2615
  const response = {
2665
2616
  $metadata: deserializeMetadata(output),
2666
2617
  ...contents,
2667
2618
  };
2668
- return Promise.resolve(response);
2619
+ return response;
2669
2620
  };
2670
2621
  const de_ListByteMatchSetsCommandError = async (output, context) => {
2671
2622
  const parsedOutput = {
@@ -2682,10 +2633,9 @@ const de_ListByteMatchSetsCommandError = async (output, context) => {
2682
2633
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
2683
2634
  default:
2684
2635
  const parsedBody = parsedOutput.body;
2685
- throwDefaultError({
2636
+ return throwDefaultError({
2686
2637
  output,
2687
2638
  parsedBody,
2688
- exceptionCtor: __BaseException,
2689
2639
  errorCode,
2690
2640
  });
2691
2641
  }
@@ -2696,12 +2646,12 @@ export const de_ListGeoMatchSetsCommand = async (output, context) => {
2696
2646
  }
2697
2647
  const data = await parseBody(output.body, context);
2698
2648
  let contents = {};
2699
- contents = de_ListGeoMatchSetsResponse(data, context);
2649
+ contents = _json(data);
2700
2650
  const response = {
2701
2651
  $metadata: deserializeMetadata(output),
2702
2652
  ...contents,
2703
2653
  };
2704
- return Promise.resolve(response);
2654
+ return response;
2705
2655
  };
2706
2656
  const de_ListGeoMatchSetsCommandError = async (output, context) => {
2707
2657
  const parsedOutput = {
@@ -2718,10 +2668,9 @@ const de_ListGeoMatchSetsCommandError = async (output, context) => {
2718
2668
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
2719
2669
  default:
2720
2670
  const parsedBody = parsedOutput.body;
2721
- throwDefaultError({
2671
+ return throwDefaultError({
2722
2672
  output,
2723
2673
  parsedBody,
2724
- exceptionCtor: __BaseException,
2725
2674
  errorCode,
2726
2675
  });
2727
2676
  }
@@ -2732,12 +2681,12 @@ export const de_ListIPSetsCommand = async (output, context) => {
2732
2681
  }
2733
2682
  const data = await parseBody(output.body, context);
2734
2683
  let contents = {};
2735
- contents = de_ListIPSetsResponse(data, context);
2684
+ contents = _json(data);
2736
2685
  const response = {
2737
2686
  $metadata: deserializeMetadata(output),
2738
2687
  ...contents,
2739
2688
  };
2740
- return Promise.resolve(response);
2689
+ return response;
2741
2690
  };
2742
2691
  const de_ListIPSetsCommandError = async (output, context) => {
2743
2692
  const parsedOutput = {
@@ -2754,10 +2703,9 @@ const de_ListIPSetsCommandError = async (output, context) => {
2754
2703
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
2755
2704
  default:
2756
2705
  const parsedBody = parsedOutput.body;
2757
- throwDefaultError({
2706
+ return throwDefaultError({
2758
2707
  output,
2759
2708
  parsedBody,
2760
- exceptionCtor: __BaseException,
2761
2709
  errorCode,
2762
2710
  });
2763
2711
  }
@@ -2768,12 +2716,12 @@ export const de_ListLoggingConfigurationsCommand = async (output, context) => {
2768
2716
  }
2769
2717
  const data = await parseBody(output.body, context);
2770
2718
  let contents = {};
2771
- contents = de_ListLoggingConfigurationsResponse(data, context);
2719
+ contents = _json(data);
2772
2720
  const response = {
2773
2721
  $metadata: deserializeMetadata(output),
2774
2722
  ...contents,
2775
2723
  };
2776
- return Promise.resolve(response);
2724
+ return response;
2777
2725
  };
2778
2726
  const de_ListLoggingConfigurationsCommandError = async (output, context) => {
2779
2727
  const parsedOutput = {
@@ -2793,10 +2741,9 @@ const de_ListLoggingConfigurationsCommandError = async (output, context) => {
2793
2741
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2794
2742
  default:
2795
2743
  const parsedBody = parsedOutput.body;
2796
- throwDefaultError({
2744
+ return throwDefaultError({
2797
2745
  output,
2798
2746
  parsedBody,
2799
- exceptionCtor: __BaseException,
2800
2747
  errorCode,
2801
2748
  });
2802
2749
  }
@@ -2807,12 +2754,12 @@ export const de_ListRateBasedRulesCommand = async (output, context) => {
2807
2754
  }
2808
2755
  const data = await parseBody(output.body, context);
2809
2756
  let contents = {};
2810
- contents = de_ListRateBasedRulesResponse(data, context);
2757
+ contents = _json(data);
2811
2758
  const response = {
2812
2759
  $metadata: deserializeMetadata(output),
2813
2760
  ...contents,
2814
2761
  };
2815
- return Promise.resolve(response);
2762
+ return response;
2816
2763
  };
2817
2764
  const de_ListRateBasedRulesCommandError = async (output, context) => {
2818
2765
  const parsedOutput = {
@@ -2829,10 +2776,9 @@ const de_ListRateBasedRulesCommandError = async (output, context) => {
2829
2776
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
2830
2777
  default:
2831
2778
  const parsedBody = parsedOutput.body;
2832
- throwDefaultError({
2779
+ return throwDefaultError({
2833
2780
  output,
2834
2781
  parsedBody,
2835
- exceptionCtor: __BaseException,
2836
2782
  errorCode,
2837
2783
  });
2838
2784
  }
@@ -2843,12 +2789,12 @@ export const de_ListRegexMatchSetsCommand = async (output, context) => {
2843
2789
  }
2844
2790
  const data = await parseBody(output.body, context);
2845
2791
  let contents = {};
2846
- contents = de_ListRegexMatchSetsResponse(data, context);
2792
+ contents = _json(data);
2847
2793
  const response = {
2848
2794
  $metadata: deserializeMetadata(output),
2849
2795
  ...contents,
2850
2796
  };
2851
- return Promise.resolve(response);
2797
+ return response;
2852
2798
  };
2853
2799
  const de_ListRegexMatchSetsCommandError = async (output, context) => {
2854
2800
  const parsedOutput = {
@@ -2865,10 +2811,9 @@ const de_ListRegexMatchSetsCommandError = async (output, context) => {
2865
2811
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
2866
2812
  default:
2867
2813
  const parsedBody = parsedOutput.body;
2868
- throwDefaultError({
2814
+ return throwDefaultError({
2869
2815
  output,
2870
2816
  parsedBody,
2871
- exceptionCtor: __BaseException,
2872
2817
  errorCode,
2873
2818
  });
2874
2819
  }
@@ -2879,12 +2824,12 @@ export const de_ListRegexPatternSetsCommand = async (output, context) => {
2879
2824
  }
2880
2825
  const data = await parseBody(output.body, context);
2881
2826
  let contents = {};
2882
- contents = de_ListRegexPatternSetsResponse(data, context);
2827
+ contents = _json(data);
2883
2828
  const response = {
2884
2829
  $metadata: deserializeMetadata(output),
2885
2830
  ...contents,
2886
2831
  };
2887
- return Promise.resolve(response);
2832
+ return response;
2888
2833
  };
2889
2834
  const de_ListRegexPatternSetsCommandError = async (output, context) => {
2890
2835
  const parsedOutput = {
@@ -2901,10 +2846,9 @@ const de_ListRegexPatternSetsCommandError = async (output, context) => {
2901
2846
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
2902
2847
  default:
2903
2848
  const parsedBody = parsedOutput.body;
2904
- throwDefaultError({
2849
+ return throwDefaultError({
2905
2850
  output,
2906
2851
  parsedBody,
2907
- exceptionCtor: __BaseException,
2908
2852
  errorCode,
2909
2853
  });
2910
2854
  }
@@ -2915,12 +2859,12 @@ export const de_ListResourcesForWebACLCommand = async (output, context) => {
2915
2859
  }
2916
2860
  const data = await parseBody(output.body, context);
2917
2861
  let contents = {};
2918
- contents = de_ListResourcesForWebACLResponse(data, context);
2862
+ contents = _json(data);
2919
2863
  const response = {
2920
2864
  $metadata: deserializeMetadata(output),
2921
2865
  ...contents,
2922
2866
  };
2923
- return Promise.resolve(response);
2867
+ return response;
2924
2868
  };
2925
2869
  const de_ListResourcesForWebACLCommandError = async (output, context) => {
2926
2870
  const parsedOutput = {
@@ -2943,10 +2887,9 @@ const de_ListResourcesForWebACLCommandError = async (output, context) => {
2943
2887
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
2944
2888
  default:
2945
2889
  const parsedBody = parsedOutput.body;
2946
- throwDefaultError({
2890
+ return throwDefaultError({
2947
2891
  output,
2948
2892
  parsedBody,
2949
- exceptionCtor: __BaseException,
2950
2893
  errorCode,
2951
2894
  });
2952
2895
  }
@@ -2957,12 +2900,12 @@ export const de_ListRuleGroupsCommand = async (output, context) => {
2957
2900
  }
2958
2901
  const data = await parseBody(output.body, context);
2959
2902
  let contents = {};
2960
- contents = de_ListRuleGroupsResponse(data, context);
2903
+ contents = _json(data);
2961
2904
  const response = {
2962
2905
  $metadata: deserializeMetadata(output),
2963
2906
  ...contents,
2964
2907
  };
2965
- return Promise.resolve(response);
2908
+ return response;
2966
2909
  };
2967
2910
  const de_ListRuleGroupsCommandError = async (output, context) => {
2968
2911
  const parsedOutput = {
@@ -2976,10 +2919,9 @@ const de_ListRuleGroupsCommandError = async (output, context) => {
2976
2919
  throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
2977
2920
  default:
2978
2921
  const parsedBody = parsedOutput.body;
2979
- throwDefaultError({
2922
+ return throwDefaultError({
2980
2923
  output,
2981
2924
  parsedBody,
2982
- exceptionCtor: __BaseException,
2983
2925
  errorCode,
2984
2926
  });
2985
2927
  }
@@ -2990,12 +2932,12 @@ export const de_ListRulesCommand = async (output, context) => {
2990
2932
  }
2991
2933
  const data = await parseBody(output.body, context);
2992
2934
  let contents = {};
2993
- contents = de_ListRulesResponse(data, context);
2935
+ contents = _json(data);
2994
2936
  const response = {
2995
2937
  $metadata: deserializeMetadata(output),
2996
2938
  ...contents,
2997
2939
  };
2998
- return Promise.resolve(response);
2940
+ return response;
2999
2941
  };
3000
2942
  const de_ListRulesCommandError = async (output, context) => {
3001
2943
  const parsedOutput = {
@@ -3012,10 +2954,9 @@ const de_ListRulesCommandError = async (output, context) => {
3012
2954
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
3013
2955
  default:
3014
2956
  const parsedBody = parsedOutput.body;
3015
- throwDefaultError({
2957
+ return throwDefaultError({
3016
2958
  output,
3017
2959
  parsedBody,
3018
- exceptionCtor: __BaseException,
3019
2960
  errorCode,
3020
2961
  });
3021
2962
  }
@@ -3026,12 +2967,12 @@ export const de_ListSizeConstraintSetsCommand = async (output, context) => {
3026
2967
  }
3027
2968
  const data = await parseBody(output.body, context);
3028
2969
  let contents = {};
3029
- contents = de_ListSizeConstraintSetsResponse(data, context);
2970
+ contents = _json(data);
3030
2971
  const response = {
3031
2972
  $metadata: deserializeMetadata(output),
3032
2973
  ...contents,
3033
2974
  };
3034
- return Promise.resolve(response);
2975
+ return response;
3035
2976
  };
3036
2977
  const de_ListSizeConstraintSetsCommandError = async (output, context) => {
3037
2978
  const parsedOutput = {
@@ -3048,10 +2989,9 @@ const de_ListSizeConstraintSetsCommandError = async (output, context) => {
3048
2989
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
3049
2990
  default:
3050
2991
  const parsedBody = parsedOutput.body;
3051
- throwDefaultError({
2992
+ return throwDefaultError({
3052
2993
  output,
3053
2994
  parsedBody,
3054
- exceptionCtor: __BaseException,
3055
2995
  errorCode,
3056
2996
  });
3057
2997
  }
@@ -3062,12 +3002,12 @@ export const de_ListSqlInjectionMatchSetsCommand = async (output, context) => {
3062
3002
  }
3063
3003
  const data = await parseBody(output.body, context);
3064
3004
  let contents = {};
3065
- contents = de_ListSqlInjectionMatchSetsResponse(data, context);
3005
+ contents = _json(data);
3066
3006
  const response = {
3067
3007
  $metadata: deserializeMetadata(output),
3068
3008
  ...contents,
3069
3009
  };
3070
- return Promise.resolve(response);
3010
+ return response;
3071
3011
  };
3072
3012
  const de_ListSqlInjectionMatchSetsCommandError = async (output, context) => {
3073
3013
  const parsedOutput = {
@@ -3084,10 +3024,9 @@ const de_ListSqlInjectionMatchSetsCommandError = async (output, context) => {
3084
3024
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
3085
3025
  default:
3086
3026
  const parsedBody = parsedOutput.body;
3087
- throwDefaultError({
3027
+ return throwDefaultError({
3088
3028
  output,
3089
3029
  parsedBody,
3090
- exceptionCtor: __BaseException,
3091
3030
  errorCode,
3092
3031
  });
3093
3032
  }
@@ -3098,12 +3037,12 @@ export const de_ListSubscribedRuleGroupsCommand = async (output, context) => {
3098
3037
  }
3099
3038
  const data = await parseBody(output.body, context);
3100
3039
  let contents = {};
3101
- contents = de_ListSubscribedRuleGroupsResponse(data, context);
3040
+ contents = _json(data);
3102
3041
  const response = {
3103
3042
  $metadata: deserializeMetadata(output),
3104
3043
  ...contents,
3105
3044
  };
3106
- return Promise.resolve(response);
3045
+ return response;
3107
3046
  };
3108
3047
  const de_ListSubscribedRuleGroupsCommandError = async (output, context) => {
3109
3048
  const parsedOutput = {
@@ -3120,10 +3059,9 @@ const de_ListSubscribedRuleGroupsCommandError = async (output, context) => {
3120
3059
  throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
3121
3060
  default:
3122
3061
  const parsedBody = parsedOutput.body;
3123
- throwDefaultError({
3062
+ return throwDefaultError({
3124
3063
  output,
3125
3064
  parsedBody,
3126
- exceptionCtor: __BaseException,
3127
3065
  errorCode,
3128
3066
  });
3129
3067
  }
@@ -3134,12 +3072,12 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
3134
3072
  }
3135
3073
  const data = await parseBody(output.body, context);
3136
3074
  let contents = {};
3137
- contents = de_ListTagsForResourceResponse(data, context);
3075
+ contents = _json(data);
3138
3076
  const response = {
3139
3077
  $metadata: deserializeMetadata(output),
3140
3078
  ...contents,
3141
3079
  };
3142
- return Promise.resolve(response);
3080
+ return response;
3143
3081
  };
3144
3082
  const de_ListTagsForResourceCommandError = async (output, context) => {
3145
3083
  const parsedOutput = {
@@ -3168,10 +3106,9 @@ const de_ListTagsForResourceCommandError = async (output, context) => {
3168
3106
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
3169
3107
  default:
3170
3108
  const parsedBody = parsedOutput.body;
3171
- throwDefaultError({
3109
+ return throwDefaultError({
3172
3110
  output,
3173
3111
  parsedBody,
3174
- exceptionCtor: __BaseException,
3175
3112
  errorCode,
3176
3113
  });
3177
3114
  }
@@ -3182,12 +3119,12 @@ export const de_ListWebACLsCommand = async (output, context) => {
3182
3119
  }
3183
3120
  const data = await parseBody(output.body, context);
3184
3121
  let contents = {};
3185
- contents = de_ListWebACLsResponse(data, context);
3122
+ contents = _json(data);
3186
3123
  const response = {
3187
3124
  $metadata: deserializeMetadata(output),
3188
3125
  ...contents,
3189
3126
  };
3190
- return Promise.resolve(response);
3127
+ return response;
3191
3128
  };
3192
3129
  const de_ListWebACLsCommandError = async (output, context) => {
3193
3130
  const parsedOutput = {
@@ -3204,10 +3141,9 @@ const de_ListWebACLsCommandError = async (output, context) => {
3204
3141
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
3205
3142
  default:
3206
3143
  const parsedBody = parsedOutput.body;
3207
- throwDefaultError({
3144
+ return throwDefaultError({
3208
3145
  output,
3209
3146
  parsedBody,
3210
- exceptionCtor: __BaseException,
3211
3147
  errorCode,
3212
3148
  });
3213
3149
  }
@@ -3218,12 +3154,12 @@ export const de_ListXssMatchSetsCommand = async (output, context) => {
3218
3154
  }
3219
3155
  const data = await parseBody(output.body, context);
3220
3156
  let contents = {};
3221
- contents = de_ListXssMatchSetsResponse(data, context);
3157
+ contents = _json(data);
3222
3158
  const response = {
3223
3159
  $metadata: deserializeMetadata(output),
3224
3160
  ...contents,
3225
3161
  };
3226
- return Promise.resolve(response);
3162
+ return response;
3227
3163
  };
3228
3164
  const de_ListXssMatchSetsCommandError = async (output, context) => {
3229
3165
  const parsedOutput = {
@@ -3240,10 +3176,9 @@ const de_ListXssMatchSetsCommandError = async (output, context) => {
3240
3176
  throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
3241
3177
  default:
3242
3178
  const parsedBody = parsedOutput.body;
3243
- throwDefaultError({
3179
+ return throwDefaultError({
3244
3180
  output,
3245
3181
  parsedBody,
3246
- exceptionCtor: __BaseException,
3247
3182
  errorCode,
3248
3183
  });
3249
3184
  }
@@ -3254,12 +3189,12 @@ export const de_PutLoggingConfigurationCommand = async (output, context) => {
3254
3189
  }
3255
3190
  const data = await parseBody(output.body, context);
3256
3191
  let contents = {};
3257
- contents = de_PutLoggingConfigurationResponse(data, context);
3192
+ contents = _json(data);
3258
3193
  const response = {
3259
3194
  $metadata: deserializeMetadata(output),
3260
3195
  ...contents,
3261
3196
  };
3262
- return Promise.resolve(response);
3197
+ return response;
3263
3198
  };
3264
3199
  const de_PutLoggingConfigurationCommandError = async (output, context) => {
3265
3200
  const parsedOutput = {
@@ -3282,10 +3217,9 @@ const de_PutLoggingConfigurationCommandError = async (output, context) => {
3282
3217
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3283
3218
  default:
3284
3219
  const parsedBody = parsedOutput.body;
3285
- throwDefaultError({
3220
+ return throwDefaultError({
3286
3221
  output,
3287
3222
  parsedBody,
3288
- exceptionCtor: __BaseException,
3289
3223
  errorCode,
3290
3224
  });
3291
3225
  }
@@ -3296,12 +3230,12 @@ export const de_PutPermissionPolicyCommand = async (output, context) => {
3296
3230
  }
3297
3231
  const data = await parseBody(output.body, context);
3298
3232
  let contents = {};
3299
- contents = de_PutPermissionPolicyResponse(data, context);
3233
+ contents = _json(data);
3300
3234
  const response = {
3301
3235
  $metadata: deserializeMetadata(output),
3302
3236
  ...contents,
3303
3237
  };
3304
- return Promise.resolve(response);
3238
+ return response;
3305
3239
  };
3306
3240
  const de_PutPermissionPolicyCommandError = async (output, context) => {
3307
3241
  const parsedOutput = {
@@ -3324,10 +3258,9 @@ const de_PutPermissionPolicyCommandError = async (output, context) => {
3324
3258
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3325
3259
  default:
3326
3260
  const parsedBody = parsedOutput.body;
3327
- throwDefaultError({
3261
+ return throwDefaultError({
3328
3262
  output,
3329
3263
  parsedBody,
3330
- exceptionCtor: __BaseException,
3331
3264
  errorCode,
3332
3265
  });
3333
3266
  }
@@ -3338,12 +3271,12 @@ export const de_TagResourceCommand = async (output, context) => {
3338
3271
  }
3339
3272
  const data = await parseBody(output.body, context);
3340
3273
  let contents = {};
3341
- contents = de_TagResourceResponse(data, context);
3274
+ contents = _json(data);
3342
3275
  const response = {
3343
3276
  $metadata: deserializeMetadata(output),
3344
3277
  ...contents,
3345
3278
  };
3346
- return Promise.resolve(response);
3279
+ return response;
3347
3280
  };
3348
3281
  const de_TagResourceCommandError = async (output, context) => {
3349
3282
  const parsedOutput = {
@@ -3375,10 +3308,9 @@ const de_TagResourceCommandError = async (output, context) => {
3375
3308
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
3376
3309
  default:
3377
3310
  const parsedBody = parsedOutput.body;
3378
- throwDefaultError({
3311
+ return throwDefaultError({
3379
3312
  output,
3380
3313
  parsedBody,
3381
- exceptionCtor: __BaseException,
3382
3314
  errorCode,
3383
3315
  });
3384
3316
  }
@@ -3389,12 +3321,12 @@ export const de_UntagResourceCommand = async (output, context) => {
3389
3321
  }
3390
3322
  const data = await parseBody(output.body, context);
3391
3323
  let contents = {};
3392
- contents = de_UntagResourceResponse(data, context);
3324
+ contents = _json(data);
3393
3325
  const response = {
3394
3326
  $metadata: deserializeMetadata(output),
3395
3327
  ...contents,
3396
3328
  };
3397
- return Promise.resolve(response);
3329
+ return response;
3398
3330
  };
3399
3331
  const de_UntagResourceCommandError = async (output, context) => {
3400
3332
  const parsedOutput = {
@@ -3423,10 +3355,9 @@ const de_UntagResourceCommandError = async (output, context) => {
3423
3355
  throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
3424
3356
  default:
3425
3357
  const parsedBody = parsedOutput.body;
3426
- throwDefaultError({
3358
+ return throwDefaultError({
3427
3359
  output,
3428
3360
  parsedBody,
3429
- exceptionCtor: __BaseException,
3430
3361
  errorCode,
3431
3362
  });
3432
3363
  }
@@ -3437,12 +3368,12 @@ export const de_UpdateByteMatchSetCommand = async (output, context) => {
3437
3368
  }
3438
3369
  const data = await parseBody(output.body, context);
3439
3370
  let contents = {};
3440
- contents = de_UpdateByteMatchSetResponse(data, context);
3371
+ contents = _json(data);
3441
3372
  const response = {
3442
3373
  $metadata: deserializeMetadata(output),
3443
3374
  ...contents,
3444
3375
  };
3445
- return Promise.resolve(response);
3376
+ return response;
3446
3377
  };
3447
3378
  const de_UpdateByteMatchSetCommandError = async (output, context) => {
3448
3379
  const parsedOutput = {
@@ -3477,10 +3408,9 @@ const de_UpdateByteMatchSetCommandError = async (output, context) => {
3477
3408
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3478
3409
  default:
3479
3410
  const parsedBody = parsedOutput.body;
3480
- throwDefaultError({
3411
+ return throwDefaultError({
3481
3412
  output,
3482
3413
  parsedBody,
3483
- exceptionCtor: __BaseException,
3484
3414
  errorCode,
3485
3415
  });
3486
3416
  }
@@ -3491,12 +3421,12 @@ export const de_UpdateGeoMatchSetCommand = async (output, context) => {
3491
3421
  }
3492
3422
  const data = await parseBody(output.body, context);
3493
3423
  let contents = {};
3494
- contents = de_UpdateGeoMatchSetResponse(data, context);
3424
+ contents = _json(data);
3495
3425
  const response = {
3496
3426
  $metadata: deserializeMetadata(output),
3497
3427
  ...contents,
3498
3428
  };
3499
- return Promise.resolve(response);
3429
+ return response;
3500
3430
  };
3501
3431
  const de_UpdateGeoMatchSetCommandError = async (output, context) => {
3502
3432
  const parsedOutput = {
@@ -3534,10 +3464,9 @@ const de_UpdateGeoMatchSetCommandError = async (output, context) => {
3534
3464
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3535
3465
  default:
3536
3466
  const parsedBody = parsedOutput.body;
3537
- throwDefaultError({
3467
+ return throwDefaultError({
3538
3468
  output,
3539
3469
  parsedBody,
3540
- exceptionCtor: __BaseException,
3541
3470
  errorCode,
3542
3471
  });
3543
3472
  }
@@ -3548,12 +3477,12 @@ export const de_UpdateIPSetCommand = async (output, context) => {
3548
3477
  }
3549
3478
  const data = await parseBody(output.body, context);
3550
3479
  let contents = {};
3551
- contents = de_UpdateIPSetResponse(data, context);
3480
+ contents = _json(data);
3552
3481
  const response = {
3553
3482
  $metadata: deserializeMetadata(output),
3554
3483
  ...contents,
3555
3484
  };
3556
- return Promise.resolve(response);
3485
+ return response;
3557
3486
  };
3558
3487
  const de_UpdateIPSetCommandError = async (output, context) => {
3559
3488
  const parsedOutput = {
@@ -3591,10 +3520,9 @@ const de_UpdateIPSetCommandError = async (output, context) => {
3591
3520
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3592
3521
  default:
3593
3522
  const parsedBody = parsedOutput.body;
3594
- throwDefaultError({
3523
+ return throwDefaultError({
3595
3524
  output,
3596
3525
  parsedBody,
3597
- exceptionCtor: __BaseException,
3598
3526
  errorCode,
3599
3527
  });
3600
3528
  }
@@ -3605,12 +3533,12 @@ export const de_UpdateRateBasedRuleCommand = async (output, context) => {
3605
3533
  }
3606
3534
  const data = await parseBody(output.body, context);
3607
3535
  let contents = {};
3608
- contents = de_UpdateRateBasedRuleResponse(data, context);
3536
+ contents = _json(data);
3609
3537
  const response = {
3610
3538
  $metadata: deserializeMetadata(output),
3611
3539
  ...contents,
3612
3540
  };
3613
- return Promise.resolve(response);
3541
+ return response;
3614
3542
  };
3615
3543
  const de_UpdateRateBasedRuleCommandError = async (output, context) => {
3616
3544
  const parsedOutput = {
@@ -3648,10 +3576,9 @@ const de_UpdateRateBasedRuleCommandError = async (output, context) => {
3648
3576
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3649
3577
  default:
3650
3578
  const parsedBody = parsedOutput.body;
3651
- throwDefaultError({
3579
+ return throwDefaultError({
3652
3580
  output,
3653
3581
  parsedBody,
3654
- exceptionCtor: __BaseException,
3655
3582
  errorCode,
3656
3583
  });
3657
3584
  }
@@ -3662,12 +3589,12 @@ export const de_UpdateRegexMatchSetCommand = async (output, context) => {
3662
3589
  }
3663
3590
  const data = await parseBody(output.body, context);
3664
3591
  let contents = {};
3665
- contents = de_UpdateRegexMatchSetResponse(data, context);
3592
+ contents = _json(data);
3666
3593
  const response = {
3667
3594
  $metadata: deserializeMetadata(output),
3668
3595
  ...contents,
3669
3596
  };
3670
- return Promise.resolve(response);
3597
+ return response;
3671
3598
  };
3672
3599
  const de_UpdateRegexMatchSetCommandError = async (output, context) => {
3673
3600
  const parsedOutput = {
@@ -3702,10 +3629,9 @@ const de_UpdateRegexMatchSetCommandError = async (output, context) => {
3702
3629
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3703
3630
  default:
3704
3631
  const parsedBody = parsedOutput.body;
3705
- throwDefaultError({
3632
+ return throwDefaultError({
3706
3633
  output,
3707
3634
  parsedBody,
3708
- exceptionCtor: __BaseException,
3709
3635
  errorCode,
3710
3636
  });
3711
3637
  }
@@ -3716,12 +3642,12 @@ export const de_UpdateRegexPatternSetCommand = async (output, context) => {
3716
3642
  }
3717
3643
  const data = await parseBody(output.body, context);
3718
3644
  let contents = {};
3719
- contents = de_UpdateRegexPatternSetResponse(data, context);
3645
+ contents = _json(data);
3720
3646
  const response = {
3721
3647
  $metadata: deserializeMetadata(output),
3722
3648
  ...contents,
3723
3649
  };
3724
- return Promise.resolve(response);
3650
+ return response;
3725
3651
  };
3726
3652
  const de_UpdateRegexPatternSetCommandError = async (output, context) => {
3727
3653
  const parsedOutput = {
@@ -3756,10 +3682,9 @@ const de_UpdateRegexPatternSetCommandError = async (output, context) => {
3756
3682
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3757
3683
  default:
3758
3684
  const parsedBody = parsedOutput.body;
3759
- throwDefaultError({
3685
+ return throwDefaultError({
3760
3686
  output,
3761
3687
  parsedBody,
3762
- exceptionCtor: __BaseException,
3763
3688
  errorCode,
3764
3689
  });
3765
3690
  }
@@ -3770,12 +3695,12 @@ export const de_UpdateRuleCommand = async (output, context) => {
3770
3695
  }
3771
3696
  const data = await parseBody(output.body, context);
3772
3697
  let contents = {};
3773
- contents = de_UpdateRuleResponse(data, context);
3698
+ contents = _json(data);
3774
3699
  const response = {
3775
3700
  $metadata: deserializeMetadata(output),
3776
3701
  ...contents,
3777
3702
  };
3778
- return Promise.resolve(response);
3703
+ return response;
3779
3704
  };
3780
3705
  const de_UpdateRuleCommandError = async (output, context) => {
3781
3706
  const parsedOutput = {
@@ -3813,10 +3738,9 @@ const de_UpdateRuleCommandError = async (output, context) => {
3813
3738
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3814
3739
  default:
3815
3740
  const parsedBody = parsedOutput.body;
3816
- throwDefaultError({
3741
+ return throwDefaultError({
3817
3742
  output,
3818
3743
  parsedBody,
3819
- exceptionCtor: __BaseException,
3820
3744
  errorCode,
3821
3745
  });
3822
3746
  }
@@ -3827,12 +3751,12 @@ export const de_UpdateRuleGroupCommand = async (output, context) => {
3827
3751
  }
3828
3752
  const data = await parseBody(output.body, context);
3829
3753
  let contents = {};
3830
- contents = de_UpdateRuleGroupResponse(data, context);
3754
+ contents = _json(data);
3831
3755
  const response = {
3832
3756
  $metadata: deserializeMetadata(output),
3833
3757
  ...contents,
3834
3758
  };
3835
- return Promise.resolve(response);
3759
+ return response;
3836
3760
  };
3837
3761
  const de_UpdateRuleGroupCommandError = async (output, context) => {
3838
3762
  const parsedOutput = {
@@ -3864,10 +3788,9 @@ const de_UpdateRuleGroupCommandError = async (output, context) => {
3864
3788
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3865
3789
  default:
3866
3790
  const parsedBody = parsedOutput.body;
3867
- throwDefaultError({
3791
+ return throwDefaultError({
3868
3792
  output,
3869
3793
  parsedBody,
3870
- exceptionCtor: __BaseException,
3871
3794
  errorCode,
3872
3795
  });
3873
3796
  }
@@ -3878,12 +3801,12 @@ export const de_UpdateSizeConstraintSetCommand = async (output, context) => {
3878
3801
  }
3879
3802
  const data = await parseBody(output.body, context);
3880
3803
  let contents = {};
3881
- contents = de_UpdateSizeConstraintSetResponse(data, context);
3804
+ contents = _json(data);
3882
3805
  const response = {
3883
3806
  $metadata: deserializeMetadata(output),
3884
3807
  ...contents,
3885
3808
  };
3886
- return Promise.resolve(response);
3809
+ return response;
3887
3810
  };
3888
3811
  const de_UpdateSizeConstraintSetCommandError = async (output, context) => {
3889
3812
  const parsedOutput = {
@@ -3921,10 +3844,9 @@ const de_UpdateSizeConstraintSetCommandError = async (output, context) => {
3921
3844
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3922
3845
  default:
3923
3846
  const parsedBody = parsedOutput.body;
3924
- throwDefaultError({
3847
+ return throwDefaultError({
3925
3848
  output,
3926
3849
  parsedBody,
3927
- exceptionCtor: __BaseException,
3928
3850
  errorCode,
3929
3851
  });
3930
3852
  }
@@ -3935,12 +3857,12 @@ export const de_UpdateSqlInjectionMatchSetCommand = async (output, context) => {
3935
3857
  }
3936
3858
  const data = await parseBody(output.body, context);
3937
3859
  let contents = {};
3938
- contents = de_UpdateSqlInjectionMatchSetResponse(data, context);
3860
+ contents = _json(data);
3939
3861
  const response = {
3940
3862
  $metadata: deserializeMetadata(output),
3941
3863
  ...contents,
3942
3864
  };
3943
- return Promise.resolve(response);
3865
+ return response;
3944
3866
  };
3945
3867
  const de_UpdateSqlInjectionMatchSetCommandError = async (output, context) => {
3946
3868
  const parsedOutput = {
@@ -3975,10 +3897,9 @@ const de_UpdateSqlInjectionMatchSetCommandError = async (output, context) => {
3975
3897
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
3976
3898
  default:
3977
3899
  const parsedBody = parsedOutput.body;
3978
- throwDefaultError({
3900
+ return throwDefaultError({
3979
3901
  output,
3980
3902
  parsedBody,
3981
- exceptionCtor: __BaseException,
3982
3903
  errorCode,
3983
3904
  });
3984
3905
  }
@@ -3989,12 +3910,12 @@ export const de_UpdateWebACLCommand = async (output, context) => {
3989
3910
  }
3990
3911
  const data = await parseBody(output.body, context);
3991
3912
  let contents = {};
3992
- contents = de_UpdateWebACLResponse(data, context);
3913
+ contents = _json(data);
3993
3914
  const response = {
3994
3915
  $metadata: deserializeMetadata(output),
3995
3916
  ...contents,
3996
3917
  };
3997
- return Promise.resolve(response);
3918
+ return response;
3998
3919
  };
3999
3920
  const de_UpdateWebACLCommandError = async (output, context) => {
4000
3921
  const parsedOutput = {
@@ -4035,10 +3956,9 @@ const de_UpdateWebACLCommandError = async (output, context) => {
4035
3956
  throw await de_WAFSubscriptionNotFoundExceptionRes(parsedOutput, context);
4036
3957
  default:
4037
3958
  const parsedBody = parsedOutput.body;
4038
- throwDefaultError({
3959
+ return throwDefaultError({
4039
3960
  output,
4040
3961
  parsedBody,
4041
- exceptionCtor: __BaseException,
4042
3962
  errorCode,
4043
3963
  });
4044
3964
  }
@@ -4049,12 +3969,12 @@ export const de_UpdateXssMatchSetCommand = async (output, context) => {
4049
3969
  }
4050
3970
  const data = await parseBody(output.body, context);
4051
3971
  let contents = {};
4052
- contents = de_UpdateXssMatchSetResponse(data, context);
3972
+ contents = _json(data);
4053
3973
  const response = {
4054
3974
  $metadata: deserializeMetadata(output),
4055
3975
  ...contents,
4056
3976
  };
4057
- return Promise.resolve(response);
3977
+ return response;
4058
3978
  };
4059
3979
  const de_UpdateXssMatchSetCommandError = async (output, context) => {
4060
3980
  const parsedOutput = {
@@ -4089,17 +4009,16 @@ const de_UpdateXssMatchSetCommandError = async (output, context) => {
4089
4009
  throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
4090
4010
  default:
4091
4011
  const parsedBody = parsedOutput.body;
4092
- throwDefaultError({
4012
+ return throwDefaultError({
4093
4013
  output,
4094
4014
  parsedBody,
4095
- exceptionCtor: __BaseException,
4096
4015
  errorCode,
4097
4016
  });
4098
4017
  }
4099
4018
  };
4100
4019
  const de_WAFBadRequestExceptionRes = async (parsedOutput, context) => {
4101
4020
  const body = parsedOutput.body;
4102
- const deserialized = de_WAFBadRequestException(body, context);
4021
+ const deserialized = _json(body);
4103
4022
  const exception = new WAFBadRequestException({
4104
4023
  $metadata: deserializeMetadata(parsedOutput),
4105
4024
  ...deserialized,
@@ -4108,7 +4027,7 @@ const de_WAFBadRequestExceptionRes = async (parsedOutput, context) => {
4108
4027
  };
4109
4028
  const de_WAFDisallowedNameExceptionRes = async (parsedOutput, context) => {
4110
4029
  const body = parsedOutput.body;
4111
- const deserialized = de_WAFDisallowedNameException(body, context);
4030
+ const deserialized = _json(body);
4112
4031
  const exception = new WAFDisallowedNameException({
4113
4032
  $metadata: deserializeMetadata(parsedOutput),
4114
4033
  ...deserialized,
@@ -4117,7 +4036,7 @@ const de_WAFDisallowedNameExceptionRes = async (parsedOutput, context) => {
4117
4036
  };
4118
4037
  const de_WAFEntityMigrationExceptionRes = async (parsedOutput, context) => {
4119
4038
  const body = parsedOutput.body;
4120
- const deserialized = de_WAFEntityMigrationException(body, context);
4039
+ const deserialized = _json(body);
4121
4040
  const exception = new WAFEntityMigrationException({
4122
4041
  $metadata: deserializeMetadata(parsedOutput),
4123
4042
  ...deserialized,
@@ -4126,7 +4045,7 @@ const de_WAFEntityMigrationExceptionRes = async (parsedOutput, context) => {
4126
4045
  };
4127
4046
  const de_WAFInternalErrorExceptionRes = async (parsedOutput, context) => {
4128
4047
  const body = parsedOutput.body;
4129
- const deserialized = de_WAFInternalErrorException(body, context);
4048
+ const deserialized = _json(body);
4130
4049
  const exception = new WAFInternalErrorException({
4131
4050
  $metadata: deserializeMetadata(parsedOutput),
4132
4051
  ...deserialized,
@@ -4135,7 +4054,7 @@ const de_WAFInternalErrorExceptionRes = async (parsedOutput, context) => {
4135
4054
  };
4136
4055
  const de_WAFInvalidAccountExceptionRes = async (parsedOutput, context) => {
4137
4056
  const body = parsedOutput.body;
4138
- const deserialized = de_WAFInvalidAccountException(body, context);
4057
+ const deserialized = _json(body);
4139
4058
  const exception = new WAFInvalidAccountException({
4140
4059
  $metadata: deserializeMetadata(parsedOutput),
4141
4060
  ...deserialized,
@@ -4144,7 +4063,7 @@ const de_WAFInvalidAccountExceptionRes = async (parsedOutput, context) => {
4144
4063
  };
4145
4064
  const de_WAFInvalidOperationExceptionRes = async (parsedOutput, context) => {
4146
4065
  const body = parsedOutput.body;
4147
- const deserialized = de_WAFInvalidOperationException(body, context);
4066
+ const deserialized = _json(body);
4148
4067
  const exception = new WAFInvalidOperationException({
4149
4068
  $metadata: deserializeMetadata(parsedOutput),
4150
4069
  ...deserialized,
@@ -4153,7 +4072,7 @@ const de_WAFInvalidOperationExceptionRes = async (parsedOutput, context) => {
4153
4072
  };
4154
4073
  const de_WAFInvalidParameterExceptionRes = async (parsedOutput, context) => {
4155
4074
  const body = parsedOutput.body;
4156
- const deserialized = de_WAFInvalidParameterException(body, context);
4075
+ const deserialized = _json(body);
4157
4076
  const exception = new WAFInvalidParameterException({
4158
4077
  $metadata: deserializeMetadata(parsedOutput),
4159
4078
  ...deserialized,
@@ -4162,7 +4081,7 @@ const de_WAFInvalidParameterExceptionRes = async (parsedOutput, context) => {
4162
4081
  };
4163
4082
  const de_WAFInvalidPermissionPolicyExceptionRes = async (parsedOutput, context) => {
4164
4083
  const body = parsedOutput.body;
4165
- const deserialized = de_WAFInvalidPermissionPolicyException(body, context);
4084
+ const deserialized = _json(body);
4166
4085
  const exception = new WAFInvalidPermissionPolicyException({
4167
4086
  $metadata: deserializeMetadata(parsedOutput),
4168
4087
  ...deserialized,
@@ -4171,7 +4090,7 @@ const de_WAFInvalidPermissionPolicyExceptionRes = async (parsedOutput, context)
4171
4090
  };
4172
4091
  const de_WAFInvalidRegexPatternExceptionRes = async (parsedOutput, context) => {
4173
4092
  const body = parsedOutput.body;
4174
- const deserialized = de_WAFInvalidRegexPatternException(body, context);
4093
+ const deserialized = _json(body);
4175
4094
  const exception = new WAFInvalidRegexPatternException({
4176
4095
  $metadata: deserializeMetadata(parsedOutput),
4177
4096
  ...deserialized,
@@ -4180,7 +4099,7 @@ const de_WAFInvalidRegexPatternExceptionRes = async (parsedOutput, context) => {
4180
4099
  };
4181
4100
  const de_WAFLimitsExceededExceptionRes = async (parsedOutput, context) => {
4182
4101
  const body = parsedOutput.body;
4183
- const deserialized = de_WAFLimitsExceededException(body, context);
4102
+ const deserialized = _json(body);
4184
4103
  const exception = new WAFLimitsExceededException({
4185
4104
  $metadata: deserializeMetadata(parsedOutput),
4186
4105
  ...deserialized,
@@ -4189,7 +4108,7 @@ const de_WAFLimitsExceededExceptionRes = async (parsedOutput, context) => {
4189
4108
  };
4190
4109
  const de_WAFNonEmptyEntityExceptionRes = async (parsedOutput, context) => {
4191
4110
  const body = parsedOutput.body;
4192
- const deserialized = de_WAFNonEmptyEntityException(body, context);
4111
+ const deserialized = _json(body);
4193
4112
  const exception = new WAFNonEmptyEntityException({
4194
4113
  $metadata: deserializeMetadata(parsedOutput),
4195
4114
  ...deserialized,
@@ -4198,7 +4117,7 @@ const de_WAFNonEmptyEntityExceptionRes = async (parsedOutput, context) => {
4198
4117
  };
4199
4118
  const de_WAFNonexistentContainerExceptionRes = async (parsedOutput, context) => {
4200
4119
  const body = parsedOutput.body;
4201
- const deserialized = de_WAFNonexistentContainerException(body, context);
4120
+ const deserialized = _json(body);
4202
4121
  const exception = new WAFNonexistentContainerException({
4203
4122
  $metadata: deserializeMetadata(parsedOutput),
4204
4123
  ...deserialized,
@@ -4207,7 +4126,7 @@ const de_WAFNonexistentContainerExceptionRes = async (parsedOutput, context) =>
4207
4126
  };
4208
4127
  const de_WAFNonexistentItemExceptionRes = async (parsedOutput, context) => {
4209
4128
  const body = parsedOutput.body;
4210
- const deserialized = de_WAFNonexistentItemException(body, context);
4129
+ const deserialized = _json(body);
4211
4130
  const exception = new WAFNonexistentItemException({
4212
4131
  $metadata: deserializeMetadata(parsedOutput),
4213
4132
  ...deserialized,
@@ -4216,7 +4135,7 @@ const de_WAFNonexistentItemExceptionRes = async (parsedOutput, context) => {
4216
4135
  };
4217
4136
  const de_WAFReferencedItemExceptionRes = async (parsedOutput, context) => {
4218
4137
  const body = parsedOutput.body;
4219
- const deserialized = de_WAFReferencedItemException(body, context);
4138
+ const deserialized = _json(body);
4220
4139
  const exception = new WAFReferencedItemException({
4221
4140
  $metadata: deserializeMetadata(parsedOutput),
4222
4141
  ...deserialized,
@@ -4225,7 +4144,7 @@ const de_WAFReferencedItemExceptionRes = async (parsedOutput, context) => {
4225
4144
  };
4226
4145
  const de_WAFServiceLinkedRoleErrorExceptionRes = async (parsedOutput, context) => {
4227
4146
  const body = parsedOutput.body;
4228
- const deserialized = de_WAFServiceLinkedRoleErrorException(body, context);
4147
+ const deserialized = _json(body);
4229
4148
  const exception = new WAFServiceLinkedRoleErrorException({
4230
4149
  $metadata: deserializeMetadata(parsedOutput),
4231
4150
  ...deserialized,
@@ -4234,7 +4153,7 @@ const de_WAFServiceLinkedRoleErrorExceptionRes = async (parsedOutput, context) =
4234
4153
  };
4235
4154
  const de_WAFStaleDataExceptionRes = async (parsedOutput, context) => {
4236
4155
  const body = parsedOutput.body;
4237
- const deserialized = de_WAFStaleDataException(body, context);
4156
+ const deserialized = _json(body);
4238
4157
  const exception = new WAFStaleDataException({
4239
4158
  $metadata: deserializeMetadata(parsedOutput),
4240
4159
  ...deserialized,
@@ -4243,7 +4162,7 @@ const de_WAFStaleDataExceptionRes = async (parsedOutput, context) => {
4243
4162
  };
4244
4163
  const de_WAFSubscriptionNotFoundExceptionRes = async (parsedOutput, context) => {
4245
4164
  const body = parsedOutput.body;
4246
- const deserialized = de_WAFSubscriptionNotFoundException(body, context);
4165
+ const deserialized = _json(body);
4247
4166
  const exception = new WAFSubscriptionNotFoundException({
4248
4167
  $metadata: deserializeMetadata(parsedOutput),
4249
4168
  ...deserialized,
@@ -4252,7 +4171,7 @@ const de_WAFSubscriptionNotFoundExceptionRes = async (parsedOutput, context) =>
4252
4171
  };
4253
4172
  const de_WAFTagOperationExceptionRes = async (parsedOutput, context) => {
4254
4173
  const body = parsedOutput.body;
4255
- const deserialized = de_WAFTagOperationException(body, context);
4174
+ const deserialized = _json(body);
4256
4175
  const exception = new WAFTagOperationException({
4257
4176
  $metadata: deserializeMetadata(parsedOutput),
4258
4177
  ...deserialized,
@@ -4261,7 +4180,7 @@ const de_WAFTagOperationExceptionRes = async (parsedOutput, context) => {
4261
4180
  };
4262
4181
  const de_WAFTagOperationInternalErrorExceptionRes = async (parsedOutput, context) => {
4263
4182
  const body = parsedOutput.body;
4264
- const deserialized = de_WAFTagOperationInternalErrorException(body, context);
4183
+ const deserialized = _json(body);
4265
4184
  const exception = new WAFTagOperationInternalErrorException({
4266
4185
  $metadata: deserializeMetadata(parsedOutput),
4267
4186
  ...deserialized,
@@ -4270,1967 +4189,118 @@ const de_WAFTagOperationInternalErrorExceptionRes = async (parsedOutput, context
4270
4189
  };
4271
4190
  const de_WAFUnavailableEntityExceptionRes = async (parsedOutput, context) => {
4272
4191
  const body = parsedOutput.body;
4273
- const deserialized = de_WAFUnavailableEntityException(body, context);
4192
+ const deserialized = _json(body);
4274
4193
  const exception = new WAFUnavailableEntityException({
4275
4194
  $metadata: deserializeMetadata(parsedOutput),
4276
4195
  ...deserialized,
4277
4196
  });
4278
4197
  return __decorateServiceException(exception, body);
4279
4198
  };
4280
- const se_ActivatedRule = (input, context) => {
4281
- return {
4282
- ...(input.Action != null && { Action: se_WafAction(input.Action, context) }),
4283
- ...(input.ExcludedRules != null && { ExcludedRules: se_ExcludedRules(input.ExcludedRules, context) }),
4284
- ...(input.OverrideAction != null && { OverrideAction: se_WafOverrideAction(input.OverrideAction, context) }),
4285
- ...(input.Priority != null && { Priority: input.Priority }),
4286
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4287
- ...(input.Type != null && { Type: input.Type }),
4288
- };
4289
- };
4290
- const se_AssociateWebACLRequest = (input, context) => {
4291
- return {
4292
- ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
4293
- ...(input.WebACLId != null && { WebACLId: input.WebACLId }),
4294
- };
4295
- };
4296
- const se_ByteMatchSetUpdate = (input, context) => {
4297
- return {
4298
- ...(input.Action != null && { Action: input.Action }),
4299
- ...(input.ByteMatchTuple != null && { ByteMatchTuple: se_ByteMatchTuple(input.ByteMatchTuple, context) }),
4300
- };
4301
- };
4302
- const se_ByteMatchSetUpdates = (input, context) => {
4303
- return input
4304
- .filter((e) => e != null)
4305
- .map((entry) => {
4306
- return se_ByteMatchSetUpdate(entry, context);
4307
- });
4308
- };
4309
- const se_ByteMatchTuple = (input, context) => {
4310
- return {
4311
- ...(input.FieldToMatch != null && { FieldToMatch: se_FieldToMatch(input.FieldToMatch, context) }),
4312
- ...(input.PositionalConstraint != null && { PositionalConstraint: input.PositionalConstraint }),
4313
- ...(input.TargetString != null && { TargetString: context.base64Encoder(input.TargetString) }),
4314
- ...(input.TextTransformation != null && { TextTransformation: input.TextTransformation }),
4315
- };
4316
- };
4317
- const se_CreateByteMatchSetRequest = (input, context) => {
4318
- return {
4319
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4320
- ...(input.Name != null && { Name: input.Name }),
4321
- };
4322
- };
4323
- const se_CreateGeoMatchSetRequest = (input, context) => {
4324
- return {
4325
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4326
- ...(input.Name != null && { Name: input.Name }),
4327
- };
4328
- };
4329
- const se_CreateIPSetRequest = (input, context) => {
4330
- return {
4331
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4332
- ...(input.Name != null && { Name: input.Name }),
4333
- };
4334
- };
4335
- const se_CreateRateBasedRuleRequest = (input, context) => {
4336
- return {
4337
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4338
- ...(input.MetricName != null && { MetricName: input.MetricName }),
4339
- ...(input.Name != null && { Name: input.Name }),
4340
- ...(input.RateKey != null && { RateKey: input.RateKey }),
4341
- ...(input.RateLimit != null && { RateLimit: input.RateLimit }),
4342
- ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
4343
- };
4344
- };
4345
- const se_CreateRegexMatchSetRequest = (input, context) => {
4346
- return {
4347
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4348
- ...(input.Name != null && { Name: input.Name }),
4349
- };
4350
- };
4351
- const se_CreateRegexPatternSetRequest = (input, context) => {
4352
- return {
4353
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4354
- ...(input.Name != null && { Name: input.Name }),
4355
- };
4356
- };
4357
- const se_CreateRuleGroupRequest = (input, context) => {
4358
- return {
4359
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4360
- ...(input.MetricName != null && { MetricName: input.MetricName }),
4361
- ...(input.Name != null && { Name: input.Name }),
4362
- ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
4363
- };
4364
- };
4365
- const se_CreateRuleRequest = (input, context) => {
4366
- return {
4367
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4368
- ...(input.MetricName != null && { MetricName: input.MetricName }),
4369
- ...(input.Name != null && { Name: input.Name }),
4370
- ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
4371
- };
4372
- };
4373
- const se_CreateSizeConstraintSetRequest = (input, context) => {
4374
- return {
4375
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4376
- ...(input.Name != null && { Name: input.Name }),
4377
- };
4378
- };
4379
- const se_CreateSqlInjectionMatchSetRequest = (input, context) => {
4380
- return {
4381
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4382
- ...(input.Name != null && { Name: input.Name }),
4383
- };
4384
- };
4385
- const se_CreateWebACLMigrationStackRequest = (input, context) => {
4386
- return {
4387
- ...(input.IgnoreUnsupportedType != null && { IgnoreUnsupportedType: input.IgnoreUnsupportedType }),
4388
- ...(input.S3BucketName != null && { S3BucketName: input.S3BucketName }),
4389
- ...(input.WebACLId != null && { WebACLId: input.WebACLId }),
4390
- };
4391
- };
4392
- const se_CreateWebACLRequest = (input, context) => {
4393
- return {
4394
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4395
- ...(input.DefaultAction != null && { DefaultAction: se_WafAction(input.DefaultAction, context) }),
4396
- ...(input.MetricName != null && { MetricName: input.MetricName }),
4397
- ...(input.Name != null && { Name: input.Name }),
4398
- ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
4399
- };
4400
- };
4401
- const se_CreateXssMatchSetRequest = (input, context) => {
4402
- return {
4403
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4404
- ...(input.Name != null && { Name: input.Name }),
4405
- };
4406
- };
4407
- const se_DeleteByteMatchSetRequest = (input, context) => {
4408
- return {
4409
- ...(input.ByteMatchSetId != null && { ByteMatchSetId: input.ByteMatchSetId }),
4410
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4411
- };
4412
- };
4413
- const se_DeleteGeoMatchSetRequest = (input, context) => {
4414
- return {
4415
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4416
- ...(input.GeoMatchSetId != null && { GeoMatchSetId: input.GeoMatchSetId }),
4417
- };
4418
- };
4419
- const se_DeleteIPSetRequest = (input, context) => {
4420
- return {
4421
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4422
- ...(input.IPSetId != null && { IPSetId: input.IPSetId }),
4423
- };
4424
- };
4425
- const se_DeleteLoggingConfigurationRequest = (input, context) => {
4426
- return {
4427
- ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
4428
- };
4429
- };
4430
- const se_DeletePermissionPolicyRequest = (input, context) => {
4431
- return {
4432
- ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
4433
- };
4434
- };
4435
- const se_DeleteRateBasedRuleRequest = (input, context) => {
4436
- return {
4437
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4438
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4439
- };
4440
- };
4441
- const se_DeleteRegexMatchSetRequest = (input, context) => {
4442
- return {
4443
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4444
- ...(input.RegexMatchSetId != null && { RegexMatchSetId: input.RegexMatchSetId }),
4445
- };
4446
- };
4447
- const se_DeleteRegexPatternSetRequest = (input, context) => {
4448
- return {
4449
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4450
- ...(input.RegexPatternSetId != null && { RegexPatternSetId: input.RegexPatternSetId }),
4451
- };
4452
- };
4453
- const se_DeleteRuleGroupRequest = (input, context) => {
4454
- return {
4455
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4456
- ...(input.RuleGroupId != null && { RuleGroupId: input.RuleGroupId }),
4457
- };
4458
- };
4459
- const se_DeleteRuleRequest = (input, context) => {
4460
- return {
4461
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4462
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4463
- };
4464
- };
4465
- const se_DeleteSizeConstraintSetRequest = (input, context) => {
4466
- return {
4467
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4468
- ...(input.SizeConstraintSetId != null && { SizeConstraintSetId: input.SizeConstraintSetId }),
4469
- };
4470
- };
4471
- const se_DeleteSqlInjectionMatchSetRequest = (input, context) => {
4472
- return {
4473
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4474
- ...(input.SqlInjectionMatchSetId != null && { SqlInjectionMatchSetId: input.SqlInjectionMatchSetId }),
4475
- };
4476
- };
4477
- const se_DeleteWebACLRequest = (input, context) => {
4478
- return {
4479
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4480
- ...(input.WebACLId != null && { WebACLId: input.WebACLId }),
4481
- };
4482
- };
4483
- const se_DeleteXssMatchSetRequest = (input, context) => {
4484
- return {
4485
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4486
- ...(input.XssMatchSetId != null && { XssMatchSetId: input.XssMatchSetId }),
4487
- };
4488
- };
4489
- const se_DisassociateWebACLRequest = (input, context) => {
4490
- return {
4491
- ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
4492
- };
4493
- };
4494
- const se_ExcludedRule = (input, context) => {
4495
- return {
4496
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4497
- };
4498
- };
4499
- const se_ExcludedRules = (input, context) => {
4500
- return input
4501
- .filter((e) => e != null)
4502
- .map((entry) => {
4503
- return se_ExcludedRule(entry, context);
4504
- });
4505
- };
4506
- const se_FieldToMatch = (input, context) => {
4507
- return {
4508
- ...(input.Data != null && { Data: input.Data }),
4509
- ...(input.Type != null && { Type: input.Type }),
4510
- };
4511
- };
4512
- const se_GeoMatchConstraint = (input, context) => {
4513
- return {
4514
- ...(input.Type != null && { Type: input.Type }),
4515
- ...(input.Value != null && { Value: input.Value }),
4516
- };
4517
- };
4518
- const se_GeoMatchSetUpdate = (input, context) => {
4519
- return {
4520
- ...(input.Action != null && { Action: input.Action }),
4521
- ...(input.GeoMatchConstraint != null && {
4522
- GeoMatchConstraint: se_GeoMatchConstraint(input.GeoMatchConstraint, context),
4523
- }),
4524
- };
4525
- };
4526
- const se_GeoMatchSetUpdates = (input, context) => {
4527
- return input
4528
- .filter((e) => e != null)
4529
- .map((entry) => {
4530
- return se_GeoMatchSetUpdate(entry, context);
4531
- });
4532
- };
4533
- const se_GetByteMatchSetRequest = (input, context) => {
4534
- return {
4535
- ...(input.ByteMatchSetId != null && { ByteMatchSetId: input.ByteMatchSetId }),
4536
- };
4537
- };
4538
- const se_GetChangeTokenRequest = (input, context) => {
4539
- return {};
4540
- };
4541
- const se_GetChangeTokenStatusRequest = (input, context) => {
4542
- return {
4543
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4544
- };
4545
- };
4546
- const se_GetGeoMatchSetRequest = (input, context) => {
4547
- return {
4548
- ...(input.GeoMatchSetId != null && { GeoMatchSetId: input.GeoMatchSetId }),
4549
- };
4550
- };
4551
- const se_GetIPSetRequest = (input, context) => {
4552
- return {
4553
- ...(input.IPSetId != null && { IPSetId: input.IPSetId }),
4554
- };
4555
- };
4556
- const se_GetLoggingConfigurationRequest = (input, context) => {
4557
- return {
4558
- ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
4559
- };
4560
- };
4561
- const se_GetPermissionPolicyRequest = (input, context) => {
4562
- return {
4563
- ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
4564
- };
4565
- };
4566
- const se_GetRateBasedRuleManagedKeysRequest = (input, context) => {
4567
- return {
4568
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4569
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4570
- };
4571
- };
4572
- const se_GetRateBasedRuleRequest = (input, context) => {
4573
- return {
4574
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4575
- };
4576
- };
4577
- const se_GetRegexMatchSetRequest = (input, context) => {
4578
- return {
4579
- ...(input.RegexMatchSetId != null && { RegexMatchSetId: input.RegexMatchSetId }),
4580
- };
4581
- };
4582
- const se_GetRegexPatternSetRequest = (input, context) => {
4583
- return {
4584
- ...(input.RegexPatternSetId != null && { RegexPatternSetId: input.RegexPatternSetId }),
4585
- };
4586
- };
4587
- const se_GetRuleGroupRequest = (input, context) => {
4588
- return {
4589
- ...(input.RuleGroupId != null && { RuleGroupId: input.RuleGroupId }),
4590
- };
4591
- };
4592
- const se_GetRuleRequest = (input, context) => {
4593
- return {
4594
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4595
- };
4596
- };
4597
- const se_GetSampledRequestsRequest = (input, context) => {
4598
- return {
4599
- ...(input.MaxItems != null && { MaxItems: input.MaxItems }),
4600
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4601
- ...(input.TimeWindow != null && { TimeWindow: se_TimeWindow(input.TimeWindow, context) }),
4602
- ...(input.WebAclId != null && { WebAclId: input.WebAclId }),
4603
- };
4604
- };
4605
- const se_GetSizeConstraintSetRequest = (input, context) => {
4606
- return {
4607
- ...(input.SizeConstraintSetId != null && { SizeConstraintSetId: input.SizeConstraintSetId }),
4608
- };
4609
- };
4610
- const se_GetSqlInjectionMatchSetRequest = (input, context) => {
4611
- return {
4612
- ...(input.SqlInjectionMatchSetId != null && { SqlInjectionMatchSetId: input.SqlInjectionMatchSetId }),
4613
- };
4614
- };
4615
- const se_GetWebACLForResourceRequest = (input, context) => {
4616
- return {
4617
- ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
4618
- };
4619
- };
4620
- const se_GetWebACLRequest = (input, context) => {
4621
- return {
4622
- ...(input.WebACLId != null && { WebACLId: input.WebACLId }),
4623
- };
4624
- };
4625
- const se_GetXssMatchSetRequest = (input, context) => {
4626
- return {
4627
- ...(input.XssMatchSetId != null && { XssMatchSetId: input.XssMatchSetId }),
4628
- };
4629
- };
4630
- const se_IPSetDescriptor = (input, context) => {
4631
- return {
4632
- ...(input.Type != null && { Type: input.Type }),
4633
- ...(input.Value != null && { Value: input.Value }),
4634
- };
4635
- };
4636
- const se_IPSetUpdate = (input, context) => {
4637
- return {
4638
- ...(input.Action != null && { Action: input.Action }),
4639
- ...(input.IPSetDescriptor != null && { IPSetDescriptor: se_IPSetDescriptor(input.IPSetDescriptor, context) }),
4640
- };
4641
- };
4642
- const se_IPSetUpdates = (input, context) => {
4643
- return input
4644
- .filter((e) => e != null)
4645
- .map((entry) => {
4646
- return se_IPSetUpdate(entry, context);
4647
- });
4648
- };
4649
- const se_ListActivatedRulesInRuleGroupRequest = (input, context) => {
4650
- return {
4651
- ...(input.Limit != null && { Limit: input.Limit }),
4652
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4653
- ...(input.RuleGroupId != null && { RuleGroupId: input.RuleGroupId }),
4654
- };
4655
- };
4656
- const se_ListByteMatchSetsRequest = (input, context) => {
4657
- return {
4658
- ...(input.Limit != null && { Limit: input.Limit }),
4659
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4660
- };
4661
- };
4662
- const se_ListGeoMatchSetsRequest = (input, context) => {
4663
- return {
4664
- ...(input.Limit != null && { Limit: input.Limit }),
4665
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4666
- };
4667
- };
4668
- const se_ListIPSetsRequest = (input, context) => {
4669
- return {
4670
- ...(input.Limit != null && { Limit: input.Limit }),
4671
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4672
- };
4673
- };
4674
- const se_ListLoggingConfigurationsRequest = (input, context) => {
4675
- return {
4676
- ...(input.Limit != null && { Limit: input.Limit }),
4677
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4678
- };
4679
- };
4680
- const se_ListRateBasedRulesRequest = (input, context) => {
4681
- return {
4682
- ...(input.Limit != null && { Limit: input.Limit }),
4683
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4684
- };
4685
- };
4686
- const se_ListRegexMatchSetsRequest = (input, context) => {
4687
- return {
4688
- ...(input.Limit != null && { Limit: input.Limit }),
4689
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4690
- };
4691
- };
4692
- const se_ListRegexPatternSetsRequest = (input, context) => {
4693
- return {
4694
- ...(input.Limit != null && { Limit: input.Limit }),
4695
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4696
- };
4697
- };
4698
- const se_ListResourcesForWebACLRequest = (input, context) => {
4699
- return {
4700
- ...(input.ResourceType != null && { ResourceType: input.ResourceType }),
4701
- ...(input.WebACLId != null && { WebACLId: input.WebACLId }),
4702
- };
4703
- };
4704
- const se_ListRuleGroupsRequest = (input, context) => {
4705
- return {
4706
- ...(input.Limit != null && { Limit: input.Limit }),
4707
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4708
- };
4709
- };
4710
- const se_ListRulesRequest = (input, context) => {
4711
- return {
4712
- ...(input.Limit != null && { Limit: input.Limit }),
4713
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4714
- };
4715
- };
4716
- const se_ListSizeConstraintSetsRequest = (input, context) => {
4717
- return {
4718
- ...(input.Limit != null && { Limit: input.Limit }),
4719
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4720
- };
4721
- };
4722
- const se_ListSqlInjectionMatchSetsRequest = (input, context) => {
4723
- return {
4724
- ...(input.Limit != null && { Limit: input.Limit }),
4725
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4726
- };
4727
- };
4728
- const se_ListSubscribedRuleGroupsRequest = (input, context) => {
4729
- return {
4730
- ...(input.Limit != null && { Limit: input.Limit }),
4731
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4732
- };
4733
- };
4734
- const se_ListTagsForResourceRequest = (input, context) => {
4735
- return {
4736
- ...(input.Limit != null && { Limit: input.Limit }),
4737
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4738
- ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
4739
- };
4740
- };
4741
- const se_ListWebACLsRequest = (input, context) => {
4742
- return {
4743
- ...(input.Limit != null && { Limit: input.Limit }),
4744
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4745
- };
4746
- };
4747
- const se_ListXssMatchSetsRequest = (input, context) => {
4748
- return {
4749
- ...(input.Limit != null && { Limit: input.Limit }),
4750
- ...(input.NextMarker != null && { NextMarker: input.NextMarker }),
4751
- };
4752
- };
4753
- const se_LogDestinationConfigs = (input, context) => {
4754
- return input
4755
- .filter((e) => e != null)
4756
- .map((entry) => {
4757
- return entry;
4758
- });
4759
- };
4760
- const se_LoggingConfiguration = (input, context) => {
4761
- return {
4762
- ...(input.LogDestinationConfigs != null && {
4763
- LogDestinationConfigs: se_LogDestinationConfigs(input.LogDestinationConfigs, context),
4764
- }),
4765
- ...(input.RedactedFields != null && { RedactedFields: se_RedactedFields(input.RedactedFields, context) }),
4766
- ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
4767
- };
4768
- };
4769
- const se_Predicate = (input, context) => {
4770
- return {
4771
- ...(input.DataId != null && { DataId: input.DataId }),
4772
- ...(input.Negated != null && { Negated: input.Negated }),
4773
- ...(input.Type != null && { Type: input.Type }),
4774
- };
4775
- };
4776
- const se_PutLoggingConfigurationRequest = (input, context) => {
4777
- return {
4778
- ...(input.LoggingConfiguration != null && {
4779
- LoggingConfiguration: se_LoggingConfiguration(input.LoggingConfiguration, context),
4780
- }),
4781
- };
4782
- };
4783
- const se_PutPermissionPolicyRequest = (input, context) => {
4784
- return {
4785
- ...(input.Policy != null && { Policy: input.Policy }),
4786
- ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
4787
- };
4788
- };
4789
- const se_RedactedFields = (input, context) => {
4790
- return input
4791
- .filter((e) => e != null)
4792
- .map((entry) => {
4793
- return se_FieldToMatch(entry, context);
4794
- });
4795
- };
4796
- const se_RegexMatchSetUpdate = (input, context) => {
4797
- return {
4798
- ...(input.Action != null && { Action: input.Action }),
4799
- ...(input.RegexMatchTuple != null && { RegexMatchTuple: se_RegexMatchTuple(input.RegexMatchTuple, context) }),
4800
- };
4801
- };
4802
- const se_RegexMatchSetUpdates = (input, context) => {
4803
- return input
4804
- .filter((e) => e != null)
4805
- .map((entry) => {
4806
- return se_RegexMatchSetUpdate(entry, context);
4807
- });
4808
- };
4809
- const se_RegexMatchTuple = (input, context) => {
4810
- return {
4811
- ...(input.FieldToMatch != null && { FieldToMatch: se_FieldToMatch(input.FieldToMatch, context) }),
4812
- ...(input.RegexPatternSetId != null && { RegexPatternSetId: input.RegexPatternSetId }),
4813
- ...(input.TextTransformation != null && { TextTransformation: input.TextTransformation }),
4814
- };
4815
- };
4816
- const se_RegexPatternSetUpdate = (input, context) => {
4817
- return {
4818
- ...(input.Action != null && { Action: input.Action }),
4819
- ...(input.RegexPatternString != null && { RegexPatternString: input.RegexPatternString }),
4820
- };
4821
- };
4822
- const se_RegexPatternSetUpdates = (input, context) => {
4823
- return input
4824
- .filter((e) => e != null)
4825
- .map((entry) => {
4826
- return se_RegexPatternSetUpdate(entry, context);
4827
- });
4828
- };
4829
- const se_RuleGroupUpdate = (input, context) => {
4830
- return {
4831
- ...(input.Action != null && { Action: input.Action }),
4832
- ...(input.ActivatedRule != null && { ActivatedRule: se_ActivatedRule(input.ActivatedRule, context) }),
4833
- };
4834
- };
4835
- const se_RuleGroupUpdates = (input, context) => {
4836
- return input
4837
- .filter((e) => e != null)
4838
- .map((entry) => {
4839
- return se_RuleGroupUpdate(entry, context);
4840
- });
4841
- };
4842
- const se_RuleUpdate = (input, context) => {
4843
- return {
4844
- ...(input.Action != null && { Action: input.Action }),
4845
- ...(input.Predicate != null && { Predicate: se_Predicate(input.Predicate, context) }),
4846
- };
4847
- };
4848
- const se_RuleUpdates = (input, context) => {
4849
- return input
4850
- .filter((e) => e != null)
4851
- .map((entry) => {
4852
- return se_RuleUpdate(entry, context);
4853
- });
4854
- };
4855
- const se_SizeConstraint = (input, context) => {
4856
- return {
4857
- ...(input.ComparisonOperator != null && { ComparisonOperator: input.ComparisonOperator }),
4858
- ...(input.FieldToMatch != null && { FieldToMatch: se_FieldToMatch(input.FieldToMatch, context) }),
4859
- ...(input.Size != null && { Size: input.Size }),
4860
- ...(input.TextTransformation != null && { TextTransformation: input.TextTransformation }),
4861
- };
4862
- };
4863
- const se_SizeConstraintSetUpdate = (input, context) => {
4864
- return {
4865
- ...(input.Action != null && { Action: input.Action }),
4866
- ...(input.SizeConstraint != null && { SizeConstraint: se_SizeConstraint(input.SizeConstraint, context) }),
4867
- };
4868
- };
4869
- const se_SizeConstraintSetUpdates = (input, context) => {
4870
- return input
4871
- .filter((e) => e != null)
4872
- .map((entry) => {
4873
- return se_SizeConstraintSetUpdate(entry, context);
4874
- });
4875
- };
4876
- const se_SqlInjectionMatchSetUpdate = (input, context) => {
4877
- return {
4878
- ...(input.Action != null && { Action: input.Action }),
4879
- ...(input.SqlInjectionMatchTuple != null && {
4880
- SqlInjectionMatchTuple: se_SqlInjectionMatchTuple(input.SqlInjectionMatchTuple, context),
4881
- }),
4882
- };
4883
- };
4884
- const se_SqlInjectionMatchSetUpdates = (input, context) => {
4885
- return input
4886
- .filter((e) => e != null)
4887
- .map((entry) => {
4888
- return se_SqlInjectionMatchSetUpdate(entry, context);
4889
- });
4890
- };
4891
- const se_SqlInjectionMatchTuple = (input, context) => {
4892
- return {
4893
- ...(input.FieldToMatch != null && { FieldToMatch: se_FieldToMatch(input.FieldToMatch, context) }),
4894
- ...(input.TextTransformation != null && { TextTransformation: input.TextTransformation }),
4895
- };
4896
- };
4897
- const se_Tag = (input, context) => {
4898
- return {
4899
- ...(input.Key != null && { Key: input.Key }),
4900
- ...(input.Value != null && { Value: input.Value }),
4901
- };
4902
- };
4903
- const se_TagKeyList = (input, context) => {
4904
- return input
4905
- .filter((e) => e != null)
4906
- .map((entry) => {
4907
- return entry;
4908
- });
4909
- };
4910
- const se_TagList = (input, context) => {
4911
- return input
4912
- .filter((e) => e != null)
4913
- .map((entry) => {
4914
- return se_Tag(entry, context);
4915
- });
4916
- };
4917
- const se_TagResourceRequest = (input, context) => {
4918
- return {
4919
- ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
4920
- ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
4921
- };
4922
- };
4923
- const se_TimeWindow = (input, context) => {
4924
- return {
4925
- ...(input.EndTime != null && { EndTime: Math.round(input.EndTime.getTime() / 1000) }),
4926
- ...(input.StartTime != null && { StartTime: Math.round(input.StartTime.getTime() / 1000) }),
4927
- };
4928
- };
4929
- const se_UntagResourceRequest = (input, context) => {
4930
- return {
4931
- ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
4932
- ...(input.TagKeys != null && { TagKeys: se_TagKeyList(input.TagKeys, context) }),
4933
- };
4934
- };
4935
- const se_UpdateByteMatchSetRequest = (input, context) => {
4936
- return {
4937
- ...(input.ByteMatchSetId != null && { ByteMatchSetId: input.ByteMatchSetId }),
4938
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4939
- ...(input.Updates != null && { Updates: se_ByteMatchSetUpdates(input.Updates, context) }),
4940
- };
4941
- };
4942
- const se_UpdateGeoMatchSetRequest = (input, context) => {
4943
- return {
4944
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4945
- ...(input.GeoMatchSetId != null && { GeoMatchSetId: input.GeoMatchSetId }),
4946
- ...(input.Updates != null && { Updates: se_GeoMatchSetUpdates(input.Updates, context) }),
4947
- };
4948
- };
4949
- const se_UpdateIPSetRequest = (input, context) => {
4950
- return {
4951
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4952
- ...(input.IPSetId != null && { IPSetId: input.IPSetId }),
4953
- ...(input.Updates != null && { Updates: se_IPSetUpdates(input.Updates, context) }),
4954
- };
4955
- };
4956
- const se_UpdateRateBasedRuleRequest = (input, context) => {
4957
- return {
4958
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4959
- ...(input.RateLimit != null && { RateLimit: input.RateLimit }),
4960
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4961
- ...(input.Updates != null && { Updates: se_RuleUpdates(input.Updates, context) }),
4962
- };
4963
- };
4964
- const se_UpdateRegexMatchSetRequest = (input, context) => {
4965
- return {
4966
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4967
- ...(input.RegexMatchSetId != null && { RegexMatchSetId: input.RegexMatchSetId }),
4968
- ...(input.Updates != null && { Updates: se_RegexMatchSetUpdates(input.Updates, context) }),
4969
- };
4970
- };
4971
- const se_UpdateRegexPatternSetRequest = (input, context) => {
4972
- return {
4973
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4974
- ...(input.RegexPatternSetId != null && { RegexPatternSetId: input.RegexPatternSetId }),
4975
- ...(input.Updates != null && { Updates: se_RegexPatternSetUpdates(input.Updates, context) }),
4976
- };
4977
- };
4978
- const se_UpdateRuleGroupRequest = (input, context) => {
4979
- return {
4980
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4981
- ...(input.RuleGroupId != null && { RuleGroupId: input.RuleGroupId }),
4982
- ...(input.Updates != null && { Updates: se_RuleGroupUpdates(input.Updates, context) }),
4983
- };
4984
- };
4985
- const se_UpdateRuleRequest = (input, context) => {
4986
- return {
4987
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4988
- ...(input.RuleId != null && { RuleId: input.RuleId }),
4989
- ...(input.Updates != null && { Updates: se_RuleUpdates(input.Updates, context) }),
4990
- };
4991
- };
4992
- const se_UpdateSizeConstraintSetRequest = (input, context) => {
4993
- return {
4994
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
4995
- ...(input.SizeConstraintSetId != null && { SizeConstraintSetId: input.SizeConstraintSetId }),
4996
- ...(input.Updates != null && { Updates: se_SizeConstraintSetUpdates(input.Updates, context) }),
4997
- };
4998
- };
4999
- const se_UpdateSqlInjectionMatchSetRequest = (input, context) => {
5000
- return {
5001
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
5002
- ...(input.SqlInjectionMatchSetId != null && { SqlInjectionMatchSetId: input.SqlInjectionMatchSetId }),
5003
- ...(input.Updates != null && { Updates: se_SqlInjectionMatchSetUpdates(input.Updates, context) }),
5004
- };
5005
- };
5006
- const se_UpdateWebACLRequest = (input, context) => {
5007
- return {
5008
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
5009
- ...(input.DefaultAction != null && { DefaultAction: se_WafAction(input.DefaultAction, context) }),
5010
- ...(input.Updates != null && { Updates: se_WebACLUpdates(input.Updates, context) }),
5011
- ...(input.WebACLId != null && { WebACLId: input.WebACLId }),
5012
- };
5013
- };
5014
- const se_UpdateXssMatchSetRequest = (input, context) => {
5015
- return {
5016
- ...(input.ChangeToken != null && { ChangeToken: input.ChangeToken }),
5017
- ...(input.Updates != null && { Updates: se_XssMatchSetUpdates(input.Updates, context) }),
5018
- ...(input.XssMatchSetId != null && { XssMatchSetId: input.XssMatchSetId }),
5019
- };
5020
- };
5021
- const se_WafAction = (input, context) => {
5022
- return {
5023
- ...(input.Type != null && { Type: input.Type }),
5024
- };
5025
- };
5026
- const se_WafOverrideAction = (input, context) => {
5027
- return {
5028
- ...(input.Type != null && { Type: input.Type }),
5029
- };
5030
- };
5031
- const se_WebACLUpdate = (input, context) => {
5032
- return {
5033
- ...(input.Action != null && { Action: input.Action }),
5034
- ...(input.ActivatedRule != null && { ActivatedRule: se_ActivatedRule(input.ActivatedRule, context) }),
5035
- };
5036
- };
5037
- const se_WebACLUpdates = (input, context) => {
5038
- return input
5039
- .filter((e) => e != null)
5040
- .map((entry) => {
5041
- return se_WebACLUpdate(entry, context);
5042
- });
5043
- };
5044
- const se_XssMatchSetUpdate = (input, context) => {
5045
- return {
5046
- ...(input.Action != null && { Action: input.Action }),
5047
- ...(input.XssMatchTuple != null && { XssMatchTuple: se_XssMatchTuple(input.XssMatchTuple, context) }),
5048
- };
5049
- };
5050
- const se_XssMatchSetUpdates = (input, context) => {
5051
- return input
5052
- .filter((e) => e != null)
5053
- .map((entry) => {
5054
- return se_XssMatchSetUpdate(entry, context);
5055
- });
5056
- };
5057
- const se_XssMatchTuple = (input, context) => {
5058
- return {
5059
- ...(input.FieldToMatch != null && { FieldToMatch: se_FieldToMatch(input.FieldToMatch, context) }),
5060
- ...(input.TextTransformation != null && { TextTransformation: input.TextTransformation }),
5061
- };
5062
- };
5063
- const de_ActivatedRule = (output, context) => {
5064
- return {
5065
- Action: output.Action != null ? de_WafAction(output.Action, context) : undefined,
5066
- ExcludedRules: output.ExcludedRules != null ? de_ExcludedRules(output.ExcludedRules, context) : undefined,
5067
- OverrideAction: output.OverrideAction != null ? de_WafOverrideAction(output.OverrideAction, context) : undefined,
5068
- Priority: __expectInt32(output.Priority),
5069
- RuleId: __expectString(output.RuleId),
5070
- Type: __expectString(output.Type),
5071
- };
5072
- };
5073
- const de_ActivatedRules = (output, context) => {
5074
- const retVal = (output || [])
5075
- .filter((e) => e != null)
5076
- .map((entry) => {
5077
- if (entry === null) {
5078
- return null;
5079
- }
5080
- return de_ActivatedRule(entry, context);
5081
- });
5082
- return retVal;
5083
- };
5084
- const de_AssociateWebACLResponse = (output, context) => {
5085
- return {};
5086
- };
5087
- const de_ByteMatchSet = (output, context) => {
5088
- return {
5089
- ByteMatchSetId: __expectString(output.ByteMatchSetId),
5090
- ByteMatchTuples: output.ByteMatchTuples != null ? de_ByteMatchTuples(output.ByteMatchTuples, context) : undefined,
5091
- Name: __expectString(output.Name),
5092
- };
5093
- };
5094
- const de_ByteMatchSetSummaries = (output, context) => {
5095
- const retVal = (output || [])
5096
- .filter((e) => e != null)
5097
- .map((entry) => {
5098
- if (entry === null) {
5099
- return null;
5100
- }
5101
- return de_ByteMatchSetSummary(entry, context);
5102
- });
5103
- return retVal;
5104
- };
5105
- const de_ByteMatchSetSummary = (output, context) => {
5106
- return {
5107
- ByteMatchSetId: __expectString(output.ByteMatchSetId),
5108
- Name: __expectString(output.Name),
5109
- };
5110
- };
5111
- const de_ByteMatchTuple = (output, context) => {
5112
- return {
5113
- FieldToMatch: output.FieldToMatch != null ? de_FieldToMatch(output.FieldToMatch, context) : undefined,
5114
- PositionalConstraint: __expectString(output.PositionalConstraint),
5115
- TargetString: output.TargetString != null ? context.base64Decoder(output.TargetString) : undefined,
5116
- TextTransformation: __expectString(output.TextTransformation),
5117
- };
5118
- };
5119
- const de_ByteMatchTuples = (output, context) => {
5120
- const retVal = (output || [])
5121
- .filter((e) => e != null)
5122
- .map((entry) => {
5123
- if (entry === null) {
5124
- return null;
5125
- }
5126
- return de_ByteMatchTuple(entry, context);
5127
- });
5128
- return retVal;
5129
- };
5130
- const de_CreateByteMatchSetResponse = (output, context) => {
5131
- return {
5132
- ByteMatchSet: output.ByteMatchSet != null ? de_ByteMatchSet(output.ByteMatchSet, context) : undefined,
5133
- ChangeToken: __expectString(output.ChangeToken),
5134
- };
5135
- };
5136
- const de_CreateGeoMatchSetResponse = (output, context) => {
5137
- return {
5138
- ChangeToken: __expectString(output.ChangeToken),
5139
- GeoMatchSet: output.GeoMatchSet != null ? de_GeoMatchSet(output.GeoMatchSet, context) : undefined,
5140
- };
5141
- };
5142
- const de_CreateIPSetResponse = (output, context) => {
5143
- return {
5144
- ChangeToken: __expectString(output.ChangeToken),
5145
- IPSet: output.IPSet != null ? de_IPSet(output.IPSet, context) : undefined,
5146
- };
5147
- };
5148
- const de_CreateRateBasedRuleResponse = (output, context) => {
5149
- return {
5150
- ChangeToken: __expectString(output.ChangeToken),
5151
- Rule: output.Rule != null ? de_RateBasedRule(output.Rule, context) : undefined,
5152
- };
5153
- };
5154
- const de_CreateRegexMatchSetResponse = (output, context) => {
5155
- return {
5156
- ChangeToken: __expectString(output.ChangeToken),
5157
- RegexMatchSet: output.RegexMatchSet != null ? de_RegexMatchSet(output.RegexMatchSet, context) : undefined,
5158
- };
5159
- };
5160
- const de_CreateRegexPatternSetResponse = (output, context) => {
5161
- return {
5162
- ChangeToken: __expectString(output.ChangeToken),
5163
- RegexPatternSet: output.RegexPatternSet != null ? de_RegexPatternSet(output.RegexPatternSet, context) : undefined,
5164
- };
5165
- };
5166
- const de_CreateRuleGroupResponse = (output, context) => {
5167
- return {
5168
- ChangeToken: __expectString(output.ChangeToken),
5169
- RuleGroup: output.RuleGroup != null ? de_RuleGroup(output.RuleGroup, context) : undefined,
5170
- };
5171
- };
5172
- const de_CreateRuleResponse = (output, context) => {
5173
- return {
5174
- ChangeToken: __expectString(output.ChangeToken),
5175
- Rule: output.Rule != null ? de_Rule(output.Rule, context) : undefined,
5176
- };
5177
- };
5178
- const de_CreateSizeConstraintSetResponse = (output, context) => {
5179
- return {
5180
- ChangeToken: __expectString(output.ChangeToken),
5181
- SizeConstraintSet: output.SizeConstraintSet != null ? de_SizeConstraintSet(output.SizeConstraintSet, context) : undefined,
5182
- };
5183
- };
5184
- const de_CreateSqlInjectionMatchSetResponse = (output, context) => {
5185
- return {
5186
- ChangeToken: __expectString(output.ChangeToken),
5187
- SqlInjectionMatchSet: output.SqlInjectionMatchSet != null ? de_SqlInjectionMatchSet(output.SqlInjectionMatchSet, context) : undefined,
5188
- };
5189
- };
5190
- const de_CreateWebACLMigrationStackResponse = (output, context) => {
5191
- return {
5192
- S3ObjectUrl: __expectString(output.S3ObjectUrl),
5193
- };
5194
- };
5195
- const de_CreateWebACLResponse = (output, context) => {
5196
- return {
5197
- ChangeToken: __expectString(output.ChangeToken),
5198
- WebACL: output.WebACL != null ? de_WebACL(output.WebACL, context) : undefined,
5199
- };
5200
- };
5201
- const de_CreateXssMatchSetResponse = (output, context) => {
5202
- return {
5203
- ChangeToken: __expectString(output.ChangeToken),
5204
- XssMatchSet: output.XssMatchSet != null ? de_XssMatchSet(output.XssMatchSet, context) : undefined,
5205
- };
5206
- };
5207
- const de_DeleteByteMatchSetResponse = (output, context) => {
5208
- return {
5209
- ChangeToken: __expectString(output.ChangeToken),
5210
- };
5211
- };
5212
- const de_DeleteGeoMatchSetResponse = (output, context) => {
5213
- return {
5214
- ChangeToken: __expectString(output.ChangeToken),
5215
- };
5216
- };
5217
- const de_DeleteIPSetResponse = (output, context) => {
5218
- return {
5219
- ChangeToken: __expectString(output.ChangeToken),
5220
- };
5221
- };
5222
- const de_DeleteLoggingConfigurationResponse = (output, context) => {
5223
- return {};
5224
- };
5225
- const de_DeletePermissionPolicyResponse = (output, context) => {
5226
- return {};
5227
- };
5228
- const de_DeleteRateBasedRuleResponse = (output, context) => {
5229
- return {
5230
- ChangeToken: __expectString(output.ChangeToken),
5231
- };
5232
- };
5233
- const de_DeleteRegexMatchSetResponse = (output, context) => {
5234
- return {
5235
- ChangeToken: __expectString(output.ChangeToken),
5236
- };
5237
- };
5238
- const de_DeleteRegexPatternSetResponse = (output, context) => {
5239
- return {
5240
- ChangeToken: __expectString(output.ChangeToken),
5241
- };
5242
- };
5243
- const de_DeleteRuleGroupResponse = (output, context) => {
5244
- return {
5245
- ChangeToken: __expectString(output.ChangeToken),
5246
- };
5247
- };
5248
- const de_DeleteRuleResponse = (output, context) => {
5249
- return {
5250
- ChangeToken: __expectString(output.ChangeToken),
5251
- };
5252
- };
5253
- const de_DeleteSizeConstraintSetResponse = (output, context) => {
5254
- return {
5255
- ChangeToken: __expectString(output.ChangeToken),
5256
- };
5257
- };
5258
- const de_DeleteSqlInjectionMatchSetResponse = (output, context) => {
5259
- return {
5260
- ChangeToken: __expectString(output.ChangeToken),
5261
- };
5262
- };
5263
- const de_DeleteWebACLResponse = (output, context) => {
5264
- return {
5265
- ChangeToken: __expectString(output.ChangeToken),
5266
- };
5267
- };
5268
- const de_DeleteXssMatchSetResponse = (output, context) => {
5269
- return {
5270
- ChangeToken: __expectString(output.ChangeToken),
5271
- };
5272
- };
5273
- const de_DisassociateWebACLResponse = (output, context) => {
5274
- return {};
5275
- };
5276
- const de_ExcludedRule = (output, context) => {
5277
- return {
5278
- RuleId: __expectString(output.RuleId),
5279
- };
5280
- };
5281
- const de_ExcludedRules = (output, context) => {
5282
- const retVal = (output || [])
5283
- .filter((e) => e != null)
5284
- .map((entry) => {
5285
- if (entry === null) {
5286
- return null;
5287
- }
5288
- return de_ExcludedRule(entry, context);
5289
- });
5290
- return retVal;
5291
- };
5292
- const de_FieldToMatch = (output, context) => {
5293
- return {
5294
- Data: __expectString(output.Data),
5295
- Type: __expectString(output.Type),
5296
- };
5297
- };
5298
- const de_GeoMatchConstraint = (output, context) => {
5299
- return {
5300
- Type: __expectString(output.Type),
5301
- Value: __expectString(output.Value),
5302
- };
5303
- };
5304
- const de_GeoMatchConstraints = (output, context) => {
5305
- const retVal = (output || [])
5306
- .filter((e) => e != null)
5307
- .map((entry) => {
5308
- if (entry === null) {
5309
- return null;
5310
- }
5311
- return de_GeoMatchConstraint(entry, context);
5312
- });
5313
- return retVal;
5314
- };
5315
- const de_GeoMatchSet = (output, context) => {
5316
- return {
5317
- GeoMatchConstraints: output.GeoMatchConstraints != null ? de_GeoMatchConstraints(output.GeoMatchConstraints, context) : undefined,
5318
- GeoMatchSetId: __expectString(output.GeoMatchSetId),
5319
- Name: __expectString(output.Name),
5320
- };
5321
- };
5322
- const de_GeoMatchSetSummaries = (output, context) => {
5323
- const retVal = (output || [])
5324
- .filter((e) => e != null)
5325
- .map((entry) => {
5326
- if (entry === null) {
5327
- return null;
5328
- }
5329
- return de_GeoMatchSetSummary(entry, context);
5330
- });
5331
- return retVal;
5332
- };
5333
- const de_GeoMatchSetSummary = (output, context) => {
5334
- return {
5335
- GeoMatchSetId: __expectString(output.GeoMatchSetId),
5336
- Name: __expectString(output.Name),
5337
- };
5338
- };
5339
- const de_GetByteMatchSetResponse = (output, context) => {
5340
- return {
5341
- ByteMatchSet: output.ByteMatchSet != null ? de_ByteMatchSet(output.ByteMatchSet, context) : undefined,
5342
- };
5343
- };
5344
- const de_GetChangeTokenResponse = (output, context) => {
5345
- return {
5346
- ChangeToken: __expectString(output.ChangeToken),
5347
- };
5348
- };
5349
- const de_GetChangeTokenStatusResponse = (output, context) => {
5350
- return {
5351
- ChangeTokenStatus: __expectString(output.ChangeTokenStatus),
5352
- };
5353
- };
5354
- const de_GetGeoMatchSetResponse = (output, context) => {
5355
- return {
5356
- GeoMatchSet: output.GeoMatchSet != null ? de_GeoMatchSet(output.GeoMatchSet, context) : undefined,
5357
- };
5358
- };
5359
- const de_GetIPSetResponse = (output, context) => {
5360
- return {
5361
- IPSet: output.IPSet != null ? de_IPSet(output.IPSet, context) : undefined,
5362
- };
5363
- };
5364
- const de_GetLoggingConfigurationResponse = (output, context) => {
5365
- return {
5366
- LoggingConfiguration: output.LoggingConfiguration != null ? de_LoggingConfiguration(output.LoggingConfiguration, context) : undefined,
5367
- };
5368
- };
5369
- const de_GetPermissionPolicyResponse = (output, context) => {
5370
- return {
5371
- Policy: __expectString(output.Policy),
5372
- };
5373
- };
5374
- const de_GetRateBasedRuleManagedKeysResponse = (output, context) => {
5375
- return {
5376
- ManagedKeys: output.ManagedKeys != null ? de_ManagedKeys(output.ManagedKeys, context) : undefined,
5377
- NextMarker: __expectString(output.NextMarker),
5378
- };
5379
- };
5380
- const de_GetRateBasedRuleResponse = (output, context) => {
5381
- return {
5382
- Rule: output.Rule != null ? de_RateBasedRule(output.Rule, context) : undefined,
5383
- };
5384
- };
5385
- const de_GetRegexMatchSetResponse = (output, context) => {
5386
- return {
5387
- RegexMatchSet: output.RegexMatchSet != null ? de_RegexMatchSet(output.RegexMatchSet, context) : undefined,
5388
- };
5389
- };
5390
- const de_GetRegexPatternSetResponse = (output, context) => {
5391
- return {
5392
- RegexPatternSet: output.RegexPatternSet != null ? de_RegexPatternSet(output.RegexPatternSet, context) : undefined,
5393
- };
5394
- };
5395
- const de_GetRuleGroupResponse = (output, context) => {
5396
- return {
5397
- RuleGroup: output.RuleGroup != null ? de_RuleGroup(output.RuleGroup, context) : undefined,
5398
- };
5399
- };
5400
- const de_GetRuleResponse = (output, context) => {
5401
- return {
5402
- Rule: output.Rule != null ? de_Rule(output.Rule, context) : undefined,
5403
- };
5404
- };
5405
- const de_GetSampledRequestsResponse = (output, context) => {
5406
- return {
5407
- PopulationSize: __expectLong(output.PopulationSize),
5408
- SampledRequests: output.SampledRequests != null ? de_SampledHTTPRequests(output.SampledRequests, context) : undefined,
5409
- TimeWindow: output.TimeWindow != null ? de_TimeWindow(output.TimeWindow, context) : undefined,
5410
- };
5411
- };
5412
- const de_GetSizeConstraintSetResponse = (output, context) => {
5413
- return {
5414
- SizeConstraintSet: output.SizeConstraintSet != null ? de_SizeConstraintSet(output.SizeConstraintSet, context) : undefined,
5415
- };
5416
- };
5417
- const de_GetSqlInjectionMatchSetResponse = (output, context) => {
5418
- return {
5419
- SqlInjectionMatchSet: output.SqlInjectionMatchSet != null ? de_SqlInjectionMatchSet(output.SqlInjectionMatchSet, context) : undefined,
5420
- };
5421
- };
5422
- const de_GetWebACLForResourceResponse = (output, context) => {
5423
- return {
5424
- WebACLSummary: output.WebACLSummary != null ? de_WebACLSummary(output.WebACLSummary, context) : undefined,
5425
- };
5426
- };
5427
- const de_GetWebACLResponse = (output, context) => {
5428
- return {
5429
- WebACL: output.WebACL != null ? de_WebACL(output.WebACL, context) : undefined,
5430
- };
5431
- };
5432
- const de_GetXssMatchSetResponse = (output, context) => {
5433
- return {
5434
- XssMatchSet: output.XssMatchSet != null ? de_XssMatchSet(output.XssMatchSet, context) : undefined,
5435
- };
5436
- };
5437
- const de_HTTPHeader = (output, context) => {
5438
- return {
5439
- Name: __expectString(output.Name),
5440
- Value: __expectString(output.Value),
5441
- };
5442
- };
5443
- const de_HTTPHeaders = (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_HTTPHeader(entry, context);
5451
- });
5452
- return retVal;
5453
- };
5454
- const de_HTTPRequest = (output, context) => {
5455
- return {
5456
- ClientIP: __expectString(output.ClientIP),
5457
- Country: __expectString(output.Country),
5458
- HTTPVersion: __expectString(output.HTTPVersion),
5459
- Headers: output.Headers != null ? de_HTTPHeaders(output.Headers, context) : undefined,
5460
- Method: __expectString(output.Method),
5461
- URI: __expectString(output.URI),
5462
- };
5463
- };
5464
- const de_IPSet = (output, context) => {
5465
- return {
5466
- IPSetDescriptors: output.IPSetDescriptors != null ? de_IPSetDescriptors(output.IPSetDescriptors, context) : undefined,
5467
- IPSetId: __expectString(output.IPSetId),
5468
- Name: __expectString(output.Name),
5469
- };
5470
- };
5471
- const de_IPSetDescriptor = (output, context) => {
5472
- return {
5473
- Type: __expectString(output.Type),
5474
- Value: __expectString(output.Value),
5475
- };
5476
- };
5477
- const de_IPSetDescriptors = (output, context) => {
5478
- const retVal = (output || [])
5479
- .filter((e) => e != null)
5480
- .map((entry) => {
5481
- if (entry === null) {
5482
- return null;
5483
- }
5484
- return de_IPSetDescriptor(entry, context);
5485
- });
5486
- return retVal;
5487
- };
5488
- const de_IPSetSummaries = (output, context) => {
5489
- const retVal = (output || [])
5490
- .filter((e) => e != null)
5491
- .map((entry) => {
5492
- if (entry === null) {
5493
- return null;
5494
- }
5495
- return de_IPSetSummary(entry, context);
5496
- });
5497
- return retVal;
5498
- };
5499
- const de_IPSetSummary = (output, context) => {
5500
- return {
5501
- IPSetId: __expectString(output.IPSetId),
5502
- Name: __expectString(output.Name),
5503
- };
5504
- };
5505
- const de_ListActivatedRulesInRuleGroupResponse = (output, context) => {
5506
- return {
5507
- ActivatedRules: output.ActivatedRules != null ? de_ActivatedRules(output.ActivatedRules, context) : undefined,
5508
- NextMarker: __expectString(output.NextMarker),
5509
- };
5510
- };
5511
- const de_ListByteMatchSetsResponse = (output, context) => {
5512
- return {
5513
- ByteMatchSets: output.ByteMatchSets != null ? de_ByteMatchSetSummaries(output.ByteMatchSets, context) : undefined,
5514
- NextMarker: __expectString(output.NextMarker),
5515
- };
5516
- };
5517
- const de_ListGeoMatchSetsResponse = (output, context) => {
5518
- return {
5519
- GeoMatchSets: output.GeoMatchSets != null ? de_GeoMatchSetSummaries(output.GeoMatchSets, context) : undefined,
5520
- NextMarker: __expectString(output.NextMarker),
5521
- };
5522
- };
5523
- const de_ListIPSetsResponse = (output, context) => {
5524
- return {
5525
- IPSets: output.IPSets != null ? de_IPSetSummaries(output.IPSets, context) : undefined,
5526
- NextMarker: __expectString(output.NextMarker),
5527
- };
5528
- };
5529
- const de_ListLoggingConfigurationsResponse = (output, context) => {
5530
- return {
5531
- LoggingConfigurations: output.LoggingConfigurations != null
5532
- ? de_LoggingConfigurations(output.LoggingConfigurations, context)
5533
- : undefined,
5534
- NextMarker: __expectString(output.NextMarker),
5535
- };
5536
- };
5537
- const de_ListRateBasedRulesResponse = (output, context) => {
5538
- return {
5539
- NextMarker: __expectString(output.NextMarker),
5540
- Rules: output.Rules != null ? de_RuleSummaries(output.Rules, context) : undefined,
5541
- };
5542
- };
5543
- const de_ListRegexMatchSetsResponse = (output, context) => {
5544
- return {
5545
- NextMarker: __expectString(output.NextMarker),
5546
- RegexMatchSets: output.RegexMatchSets != null ? de_RegexMatchSetSummaries(output.RegexMatchSets, context) : undefined,
5547
- };
5548
- };
5549
- const de_ListRegexPatternSetsResponse = (output, context) => {
5550
- return {
5551
- NextMarker: __expectString(output.NextMarker),
5552
- RegexPatternSets: output.RegexPatternSets != null ? de_RegexPatternSetSummaries(output.RegexPatternSets, context) : undefined,
5553
- };
5554
- };
5555
- const de_ListResourcesForWebACLResponse = (output, context) => {
5556
- return {
5557
- ResourceArns: output.ResourceArns != null ? de_ResourceArns(output.ResourceArns, context) : undefined,
5558
- };
5559
- };
5560
- const de_ListRuleGroupsResponse = (output, context) => {
5561
- return {
5562
- NextMarker: __expectString(output.NextMarker),
5563
- RuleGroups: output.RuleGroups != null ? de_RuleGroupSummaries(output.RuleGroups, context) : undefined,
5564
- };
5565
- };
5566
- const de_ListRulesResponse = (output, context) => {
5567
- return {
5568
- NextMarker: __expectString(output.NextMarker),
5569
- Rules: output.Rules != null ? de_RuleSummaries(output.Rules, context) : undefined,
5570
- };
5571
- };
5572
- const de_ListSizeConstraintSetsResponse = (output, context) => {
5573
- return {
5574
- NextMarker: __expectString(output.NextMarker),
5575
- SizeConstraintSets: output.SizeConstraintSets != null ? de_SizeConstraintSetSummaries(output.SizeConstraintSets, context) : undefined,
5576
- };
5577
- };
5578
- const de_ListSqlInjectionMatchSetsResponse = (output, context) => {
5579
- return {
5580
- NextMarker: __expectString(output.NextMarker),
5581
- SqlInjectionMatchSets: output.SqlInjectionMatchSets != null
5582
- ? de_SqlInjectionMatchSetSummaries(output.SqlInjectionMatchSets, context)
5583
- : undefined,
5584
- };
5585
- };
5586
- const de_ListSubscribedRuleGroupsResponse = (output, context) => {
5587
- return {
5588
- NextMarker: __expectString(output.NextMarker),
5589
- RuleGroups: output.RuleGroups != null ? de_SubscribedRuleGroupSummaries(output.RuleGroups, context) : undefined,
5590
- };
5591
- };
5592
- const de_ListTagsForResourceResponse = (output, context) => {
5593
- return {
5594
- NextMarker: __expectString(output.NextMarker),
5595
- TagInfoForResource: output.TagInfoForResource != null ? de_TagInfoForResource(output.TagInfoForResource, context) : undefined,
5596
- };
5597
- };
5598
- const de_ListWebACLsResponse = (output, context) => {
5599
- return {
5600
- NextMarker: __expectString(output.NextMarker),
5601
- WebACLs: output.WebACLs != null ? de_WebACLSummaries(output.WebACLs, context) : undefined,
5602
- };
5603
- };
5604
- const de_ListXssMatchSetsResponse = (output, context) => {
5605
- return {
5606
- NextMarker: __expectString(output.NextMarker),
5607
- XssMatchSets: output.XssMatchSets != null ? de_XssMatchSetSummaries(output.XssMatchSets, context) : undefined,
5608
- };
5609
- };
5610
- const de_LogDestinationConfigs = (output, context) => {
5611
- const retVal = (output || [])
5612
- .filter((e) => e != null)
5613
- .map((entry) => {
5614
- if (entry === null) {
5615
- return null;
5616
- }
5617
- return __expectString(entry);
5618
- });
5619
- return retVal;
5620
- };
5621
- const de_LoggingConfiguration = (output, context) => {
5622
- return {
5623
- LogDestinationConfigs: output.LogDestinationConfigs != null
5624
- ? de_LogDestinationConfigs(output.LogDestinationConfigs, context)
5625
- : undefined,
5626
- RedactedFields: output.RedactedFields != null ? de_RedactedFields(output.RedactedFields, context) : undefined,
5627
- ResourceArn: __expectString(output.ResourceArn),
5628
- };
5629
- };
5630
- const de_LoggingConfigurations = (output, context) => {
5631
- const retVal = (output || [])
5632
- .filter((e) => e != null)
5633
- .map((entry) => {
5634
- if (entry === null) {
5635
- return null;
5636
- }
5637
- return de_LoggingConfiguration(entry, context);
5638
- });
5639
- return retVal;
5640
- };
5641
- const de_ManagedKeys = (output, context) => {
5642
- const retVal = (output || [])
5643
- .filter((e) => e != null)
5644
- .map((entry) => {
5645
- if (entry === null) {
5646
- return null;
5647
- }
5648
- return __expectString(entry);
5649
- });
5650
- return retVal;
5651
- };
5652
- const de_Predicate = (output, context) => {
5653
- return {
5654
- DataId: __expectString(output.DataId),
5655
- Negated: __expectBoolean(output.Negated),
5656
- Type: __expectString(output.Type),
5657
- };
5658
- };
5659
- const de_Predicates = (output, context) => {
5660
- const retVal = (output || [])
5661
- .filter((e) => e != null)
5662
- .map((entry) => {
5663
- if (entry === null) {
5664
- return null;
5665
- }
5666
- return de_Predicate(entry, context);
5667
- });
5668
- return retVal;
5669
- };
5670
- const de_PutLoggingConfigurationResponse = (output, context) => {
5671
- return {
5672
- LoggingConfiguration: output.LoggingConfiguration != null ? de_LoggingConfiguration(output.LoggingConfiguration, context) : undefined,
5673
- };
5674
- };
5675
- const de_PutPermissionPolicyResponse = (output, context) => {
5676
- return {};
5677
- };
5678
- const de_RateBasedRule = (output, context) => {
5679
- return {
5680
- MatchPredicates: output.MatchPredicates != null ? de_Predicates(output.MatchPredicates, context) : undefined,
5681
- MetricName: __expectString(output.MetricName),
5682
- Name: __expectString(output.Name),
5683
- RateKey: __expectString(output.RateKey),
5684
- RateLimit: __expectLong(output.RateLimit),
5685
- RuleId: __expectString(output.RuleId),
5686
- };
5687
- };
5688
- const de_RedactedFields = (output, context) => {
5689
- const retVal = (output || [])
5690
- .filter((e) => e != null)
5691
- .map((entry) => {
5692
- if (entry === null) {
5693
- return null;
5694
- }
5695
- return de_FieldToMatch(entry, context);
5696
- });
5697
- return retVal;
5698
- };
5699
- const de_RegexMatchSet = (output, context) => {
5700
- return {
5701
- Name: __expectString(output.Name),
5702
- RegexMatchSetId: __expectString(output.RegexMatchSetId),
5703
- RegexMatchTuples: output.RegexMatchTuples != null ? de_RegexMatchTuples(output.RegexMatchTuples, context) : undefined,
5704
- };
5705
- };
5706
- const de_RegexMatchSetSummaries = (output, context) => {
5707
- const retVal = (output || [])
5708
- .filter((e) => e != null)
5709
- .map((entry) => {
5710
- if (entry === null) {
5711
- return null;
5712
- }
5713
- return de_RegexMatchSetSummary(entry, context);
5714
- });
5715
- return retVal;
5716
- };
5717
- const de_RegexMatchSetSummary = (output, context) => {
5718
- return {
5719
- Name: __expectString(output.Name),
5720
- RegexMatchSetId: __expectString(output.RegexMatchSetId),
5721
- };
5722
- };
5723
- const de_RegexMatchTuple = (output, context) => {
5724
- return {
5725
- FieldToMatch: output.FieldToMatch != null ? de_FieldToMatch(output.FieldToMatch, context) : undefined,
5726
- RegexPatternSetId: __expectString(output.RegexPatternSetId),
5727
- TextTransformation: __expectString(output.TextTransformation),
5728
- };
5729
- };
5730
- const de_RegexMatchTuples = (output, context) => {
5731
- const retVal = (output || [])
5732
- .filter((e) => e != null)
5733
- .map((entry) => {
5734
- if (entry === null) {
5735
- return null;
5736
- }
5737
- return de_RegexMatchTuple(entry, context);
5738
- });
5739
- return retVal;
5740
- };
5741
- const de_RegexPatternSet = (output, context) => {
5742
- return {
5743
- Name: __expectString(output.Name),
5744
- RegexPatternSetId: __expectString(output.RegexPatternSetId),
5745
- RegexPatternStrings: output.RegexPatternStrings != null ? de_RegexPatternStrings(output.RegexPatternStrings, context) : undefined,
5746
- };
5747
- };
5748
- const de_RegexPatternSetSummaries = (output, context) => {
5749
- const retVal = (output || [])
5750
- .filter((e) => e != null)
5751
- .map((entry) => {
5752
- if (entry === null) {
5753
- return null;
5754
- }
5755
- return de_RegexPatternSetSummary(entry, context);
4199
+ const se_ByteMatchSetUpdate = (input, context) => {
4200
+ return take(input, {
4201
+ Action: [],
4202
+ ByteMatchTuple: (_) => se_ByteMatchTuple(_, context),
5756
4203
  });
5757
- return retVal;
5758
- };
5759
- const de_RegexPatternSetSummary = (output, context) => {
5760
- return {
5761
- Name: __expectString(output.Name),
5762
- RegexPatternSetId: __expectString(output.RegexPatternSetId),
5763
- };
5764
4204
  };
5765
- const de_RegexPatternStrings = (output, context) => {
5766
- const retVal = (output || [])
4205
+ const se_ByteMatchSetUpdates = (input, context) => {
4206
+ return input
5767
4207
  .filter((e) => e != null)
5768
4208
  .map((entry) => {
5769
- if (entry === null) {
5770
- return null;
5771
- }
5772
- return __expectString(entry);
4209
+ return se_ByteMatchSetUpdate(entry, context);
5773
4210
  });
5774
- return retVal;
5775
4211
  };
5776
- const de_ResourceArns = (output, context) => {
5777
- const retVal = (output || [])
5778
- .filter((e) => e != null)
5779
- .map((entry) => {
5780
- if (entry === null) {
5781
- return null;
5782
- }
5783
- return __expectString(entry);
4212
+ const se_ByteMatchTuple = (input, context) => {
4213
+ return take(input, {
4214
+ FieldToMatch: _json,
4215
+ PositionalConstraint: [],
4216
+ TargetString: context.base64Encoder,
4217
+ TextTransformation: [],
5784
4218
  });
5785
- return retVal;
5786
- };
5787
- const de_Rule = (output, context) => {
5788
- return {
5789
- MetricName: __expectString(output.MetricName),
5790
- Name: __expectString(output.Name),
5791
- Predicates: output.Predicates != null ? de_Predicates(output.Predicates, context) : undefined,
5792
- RuleId: __expectString(output.RuleId),
5793
- };
5794
4219
  };
5795
- const de_RuleGroup = (output, context) => {
5796
- return {
5797
- MetricName: __expectString(output.MetricName),
5798
- Name: __expectString(output.Name),
5799
- RuleGroupId: __expectString(output.RuleGroupId),
5800
- };
5801
- };
5802
- const de_RuleGroupSummaries = (output, context) => {
5803
- const retVal = (output || [])
5804
- .filter((e) => e != null)
5805
- .map((entry) => {
5806
- if (entry === null) {
5807
- return null;
5808
- }
5809
- return de_RuleGroupSummary(entry, context);
4220
+ const se_GetSampledRequestsRequest = (input, context) => {
4221
+ return take(input, {
4222
+ MaxItems: [],
4223
+ RuleId: [],
4224
+ TimeWindow: (_) => se_TimeWindow(_, context),
4225
+ WebAclId: [],
5810
4226
  });
5811
- return retVal;
5812
- };
5813
- const de_RuleGroupSummary = (output, context) => {
5814
- return {
5815
- Name: __expectString(output.Name),
5816
- RuleGroupId: __expectString(output.RuleGroupId),
5817
- };
5818
4227
  };
5819
- const de_RuleSummaries = (output, context) => {
5820
- const retVal = (output || [])
5821
- .filter((e) => e != null)
5822
- .map((entry) => {
5823
- if (entry === null) {
5824
- return null;
5825
- }
5826
- return de_RuleSummary(entry, context);
4228
+ const se_TimeWindow = (input, context) => {
4229
+ return take(input, {
4230
+ EndTime: (_) => Math.round(_.getTime() / 1000),
4231
+ StartTime: (_) => Math.round(_.getTime() / 1000),
5827
4232
  });
5828
- return retVal;
5829
- };
5830
- const de_RuleSummary = (output, context) => {
5831
- return {
5832
- Name: __expectString(output.Name),
5833
- RuleId: __expectString(output.RuleId),
5834
- };
5835
- };
5836
- const de_SampledHTTPRequest = (output, context) => {
5837
- return {
5838
- Action: __expectString(output.Action),
5839
- Request: output.Request != null ? de_HTTPRequest(output.Request, context) : undefined,
5840
- RuleWithinRuleGroup: __expectString(output.RuleWithinRuleGroup),
5841
- Timestamp: output.Timestamp != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.Timestamp))) : undefined,
5842
- Weight: __expectLong(output.Weight),
5843
- };
5844
4233
  };
5845
- const de_SampledHTTPRequests = (output, context) => {
5846
- const retVal = (output || [])
5847
- .filter((e) => e != null)
5848
- .map((entry) => {
5849
- if (entry === null) {
5850
- return null;
5851
- }
5852
- return de_SampledHTTPRequest(entry, context);
4234
+ const se_UpdateByteMatchSetRequest = (input, context) => {
4235
+ return take(input, {
4236
+ ByteMatchSetId: [],
4237
+ ChangeToken: [],
4238
+ Updates: (_) => se_ByteMatchSetUpdates(_, context),
5853
4239
  });
5854
- return retVal;
5855
- };
5856
- const de_SizeConstraint = (output, context) => {
5857
- return {
5858
- ComparisonOperator: __expectString(output.ComparisonOperator),
5859
- FieldToMatch: output.FieldToMatch != null ? de_FieldToMatch(output.FieldToMatch, context) : undefined,
5860
- Size: __expectLong(output.Size),
5861
- TextTransformation: __expectString(output.TextTransformation),
5862
- };
5863
4240
  };
5864
- const de_SizeConstraints = (output, context) => {
5865
- const retVal = (output || [])
5866
- .filter((e) => e != null)
5867
- .map((entry) => {
5868
- if (entry === null) {
5869
- return null;
5870
- }
5871
- return de_SizeConstraint(entry, context);
4241
+ const de_ByteMatchSet = (output, context) => {
4242
+ return take(output, {
4243
+ ByteMatchSetId: __expectString,
4244
+ ByteMatchTuples: (_) => de_ByteMatchTuples(_, context),
4245
+ Name: __expectString,
5872
4246
  });
5873
- return retVal;
5874
- };
5875
- const de_SizeConstraintSet = (output, context) => {
5876
- return {
5877
- Name: __expectString(output.Name),
5878
- SizeConstraintSetId: __expectString(output.SizeConstraintSetId),
5879
- SizeConstraints: output.SizeConstraints != null ? de_SizeConstraints(output.SizeConstraints, context) : undefined,
5880
- };
5881
4247
  };
5882
- const de_SizeConstraintSetSummaries = (output, context) => {
5883
- const retVal = (output || [])
5884
- .filter((e) => e != null)
5885
- .map((entry) => {
5886
- if (entry === null) {
5887
- return null;
5888
- }
5889
- return de_SizeConstraintSetSummary(entry, context);
4248
+ const de_ByteMatchTuple = (output, context) => {
4249
+ return take(output, {
4250
+ FieldToMatch: _json,
4251
+ PositionalConstraint: __expectString,
4252
+ TargetString: context.base64Decoder,
4253
+ TextTransformation: __expectString,
5890
4254
  });
5891
- return retVal;
5892
- };
5893
- const de_SizeConstraintSetSummary = (output, context) => {
5894
- return {
5895
- Name: __expectString(output.Name),
5896
- SizeConstraintSetId: __expectString(output.SizeConstraintSetId),
5897
- };
5898
- };
5899
- const de_SqlInjectionMatchSet = (output, context) => {
5900
- return {
5901
- Name: __expectString(output.Name),
5902
- SqlInjectionMatchSetId: __expectString(output.SqlInjectionMatchSetId),
5903
- SqlInjectionMatchTuples: output.SqlInjectionMatchTuples != null
5904
- ? de_SqlInjectionMatchTuples(output.SqlInjectionMatchTuples, context)
5905
- : undefined,
5906
- };
5907
4255
  };
5908
- const de_SqlInjectionMatchSetSummaries = (output, context) => {
4256
+ const de_ByteMatchTuples = (output, context) => {
5909
4257
  const retVal = (output || [])
5910
4258
  .filter((e) => e != null)
5911
4259
  .map((entry) => {
5912
- if (entry === null) {
5913
- return null;
5914
- }
5915
- return de_SqlInjectionMatchSetSummary(entry, context);
4260
+ return de_ByteMatchTuple(entry, context);
5916
4261
  });
5917
4262
  return retVal;
5918
4263
  };
5919
- const de_SqlInjectionMatchSetSummary = (output, context) => {
5920
- return {
5921
- Name: __expectString(output.Name),
5922
- SqlInjectionMatchSetId: __expectString(output.SqlInjectionMatchSetId),
5923
- };
5924
- };
5925
- const de_SqlInjectionMatchTuple = (output, context) => {
5926
- return {
5927
- FieldToMatch: output.FieldToMatch != null ? de_FieldToMatch(output.FieldToMatch, context) : undefined,
5928
- TextTransformation: __expectString(output.TextTransformation),
5929
- };
5930
- };
5931
- const de_SqlInjectionMatchTuples = (output, context) => {
5932
- const retVal = (output || [])
5933
- .filter((e) => e != null)
5934
- .map((entry) => {
5935
- if (entry === null) {
5936
- return null;
5937
- }
5938
- return de_SqlInjectionMatchTuple(entry, context);
4264
+ const de_CreateByteMatchSetResponse = (output, context) => {
4265
+ return take(output, {
4266
+ ByteMatchSet: (_) => de_ByteMatchSet(_, context),
4267
+ ChangeToken: __expectString,
5939
4268
  });
5940
- return retVal;
5941
4269
  };
5942
- const de_SubscribedRuleGroupSummaries = (output, context) => {
5943
- const retVal = (output || [])
5944
- .filter((e) => e != null)
5945
- .map((entry) => {
5946
- if (entry === null) {
5947
- return null;
5948
- }
5949
- return de_SubscribedRuleGroupSummary(entry, context);
4270
+ const de_GetByteMatchSetResponse = (output, context) => {
4271
+ return take(output, {
4272
+ ByteMatchSet: (_) => de_ByteMatchSet(_, context),
5950
4273
  });
5951
- return retVal;
5952
- };
5953
- const de_SubscribedRuleGroupSummary = (output, context) => {
5954
- return {
5955
- MetricName: __expectString(output.MetricName),
5956
- Name: __expectString(output.Name),
5957
- RuleGroupId: __expectString(output.RuleGroupId),
5958
- };
5959
- };
5960
- const de_Tag = (output, context) => {
5961
- return {
5962
- Key: __expectString(output.Key),
5963
- Value: __expectString(output.Value),
5964
- };
5965
4274
  };
5966
- const de_TagInfoForResource = (output, context) => {
5967
- return {
5968
- ResourceARN: __expectString(output.ResourceARN),
5969
- TagList: output.TagList != null ? de_TagList(output.TagList, context) : undefined,
5970
- };
5971
- };
5972
- const de_TagList = (output, context) => {
5973
- const retVal = (output || [])
5974
- .filter((e) => e != null)
5975
- .map((entry) => {
5976
- if (entry === null) {
5977
- return null;
5978
- }
5979
- return de_Tag(entry, context);
4275
+ const de_GetSampledRequestsResponse = (output, context) => {
4276
+ return take(output, {
4277
+ PopulationSize: __expectLong,
4278
+ SampledRequests: (_) => de_SampledHTTPRequests(_, context),
4279
+ TimeWindow: (_) => de_TimeWindow(_, context),
5980
4280
  });
5981
- return retVal;
5982
- };
5983
- const de_TagResourceResponse = (output, context) => {
5984
- return {};
5985
- };
5986
- const de_TimeWindow = (output, context) => {
5987
- return {
5988
- EndTime: output.EndTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.EndTime))) : undefined,
5989
- StartTime: output.StartTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartTime))) : undefined,
5990
- };
5991
- };
5992
- const de_UntagResourceResponse = (output, context) => {
5993
- return {};
5994
- };
5995
- const de_UpdateByteMatchSetResponse = (output, context) => {
5996
- return {
5997
- ChangeToken: __expectString(output.ChangeToken),
5998
- };
5999
4281
  };
6000
- const de_UpdateGeoMatchSetResponse = (output, context) => {
6001
- return {
6002
- ChangeToken: __expectString(output.ChangeToken),
6003
- };
6004
- };
6005
- const de_UpdateIPSetResponse = (output, context) => {
6006
- return {
6007
- ChangeToken: __expectString(output.ChangeToken),
6008
- };
6009
- };
6010
- const de_UpdateRateBasedRuleResponse = (output, context) => {
6011
- return {
6012
- ChangeToken: __expectString(output.ChangeToken),
6013
- };
6014
- };
6015
- const de_UpdateRegexMatchSetResponse = (output, context) => {
6016
- return {
6017
- ChangeToken: __expectString(output.ChangeToken),
6018
- };
6019
- };
6020
- const de_UpdateRegexPatternSetResponse = (output, context) => {
6021
- return {
6022
- ChangeToken: __expectString(output.ChangeToken),
6023
- };
6024
- };
6025
- const de_UpdateRuleGroupResponse = (output, context) => {
6026
- return {
6027
- ChangeToken: __expectString(output.ChangeToken),
6028
- };
6029
- };
6030
- const de_UpdateRuleResponse = (output, context) => {
6031
- return {
6032
- ChangeToken: __expectString(output.ChangeToken),
6033
- };
6034
- };
6035
- const de_UpdateSizeConstraintSetResponse = (output, context) => {
6036
- return {
6037
- ChangeToken: __expectString(output.ChangeToken),
6038
- };
6039
- };
6040
- const de_UpdateSqlInjectionMatchSetResponse = (output, context) => {
6041
- return {
6042
- ChangeToken: __expectString(output.ChangeToken),
6043
- };
6044
- };
6045
- const de_UpdateWebACLResponse = (output, context) => {
6046
- return {
6047
- ChangeToken: __expectString(output.ChangeToken),
6048
- };
6049
- };
6050
- const de_UpdateXssMatchSetResponse = (output, context) => {
6051
- return {
6052
- ChangeToken: __expectString(output.ChangeToken),
6053
- };
6054
- };
6055
- const de_WafAction = (output, context) => {
6056
- return {
6057
- Type: __expectString(output.Type),
6058
- };
6059
- };
6060
- const de_WAFBadRequestException = (output, context) => {
6061
- return {
6062
- message: __expectString(output.message),
6063
- };
6064
- };
6065
- const de_WAFDisallowedNameException = (output, context) => {
6066
- return {
6067
- message: __expectString(output.message),
6068
- };
6069
- };
6070
- const de_WAFEntityMigrationException = (output, context) => {
6071
- return {
6072
- MigrationErrorReason: __expectString(output.MigrationErrorReason),
6073
- MigrationErrorType: __expectString(output.MigrationErrorType),
6074
- message: __expectString(output.message),
6075
- };
6076
- };
6077
- const de_WAFInternalErrorException = (output, context) => {
6078
- return {
6079
- message: __expectString(output.message),
6080
- };
6081
- };
6082
- const de_WAFInvalidAccountException = (output, context) => {
6083
- return {};
6084
- };
6085
- const de_WAFInvalidOperationException = (output, context) => {
6086
- return {
6087
- message: __expectString(output.message),
6088
- };
6089
- };
6090
- const de_WAFInvalidParameterException = (output, context) => {
6091
- return {
6092
- field: __expectString(output.field),
6093
- parameter: __expectString(output.parameter),
6094
- reason: __expectString(output.reason),
6095
- };
6096
- };
6097
- const de_WAFInvalidPermissionPolicyException = (output, context) => {
6098
- return {
6099
- message: __expectString(output.message),
6100
- };
6101
- };
6102
- const de_WAFInvalidRegexPatternException = (output, context) => {
6103
- return {
6104
- message: __expectString(output.message),
6105
- };
6106
- };
6107
- const de_WAFLimitsExceededException = (output, context) => {
6108
- return {
6109
- message: __expectString(output.message),
6110
- };
6111
- };
6112
- const de_WAFNonEmptyEntityException = (output, context) => {
6113
- return {
6114
- message: __expectString(output.message),
6115
- };
6116
- };
6117
- const de_WAFNonexistentContainerException = (output, context) => {
6118
- return {
6119
- message: __expectString(output.message),
6120
- };
6121
- };
6122
- const de_WAFNonexistentItemException = (output, context) => {
6123
- return {
6124
- message: __expectString(output.message),
6125
- };
6126
- };
6127
- const de_WafOverrideAction = (output, context) => {
6128
- return {
6129
- Type: __expectString(output.Type),
6130
- };
6131
- };
6132
- const de_WAFReferencedItemException = (output, context) => {
6133
- return {
6134
- message: __expectString(output.message),
6135
- };
6136
- };
6137
- const de_WAFServiceLinkedRoleErrorException = (output, context) => {
6138
- return {
6139
- message: __expectString(output.message),
6140
- };
6141
- };
6142
- const de_WAFStaleDataException = (output, context) => {
6143
- return {
6144
- message: __expectString(output.message),
6145
- };
6146
- };
6147
- const de_WAFSubscriptionNotFoundException = (output, context) => {
6148
- return {
6149
- message: __expectString(output.message),
6150
- };
6151
- };
6152
- const de_WAFTagOperationException = (output, context) => {
6153
- return {
6154
- message: __expectString(output.message),
6155
- };
6156
- };
6157
- const de_WAFTagOperationInternalErrorException = (output, context) => {
6158
- return {
6159
- message: __expectString(output.message),
6160
- };
6161
- };
6162
- const de_WAFUnavailableEntityException = (output, context) => {
6163
- return {
6164
- message: __expectString(output.message),
6165
- };
6166
- };
6167
- const de_WebACL = (output, context) => {
6168
- return {
6169
- DefaultAction: output.DefaultAction != null ? de_WafAction(output.DefaultAction, context) : undefined,
6170
- MetricName: __expectString(output.MetricName),
6171
- Name: __expectString(output.Name),
6172
- Rules: output.Rules != null ? de_ActivatedRules(output.Rules, context) : undefined,
6173
- WebACLArn: __expectString(output.WebACLArn),
6174
- WebACLId: __expectString(output.WebACLId),
6175
- };
6176
- };
6177
- const de_WebACLSummaries = (output, context) => {
6178
- const retVal = (output || [])
6179
- .filter((e) => e != null)
6180
- .map((entry) => {
6181
- if (entry === null) {
6182
- return null;
6183
- }
6184
- return de_WebACLSummary(entry, context);
4282
+ const de_SampledHTTPRequest = (output, context) => {
4283
+ return take(output, {
4284
+ Action: __expectString,
4285
+ Request: _json,
4286
+ RuleWithinRuleGroup: __expectString,
4287
+ Timestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
4288
+ Weight: __expectLong,
6185
4289
  });
6186
- return retVal;
6187
- };
6188
- const de_WebACLSummary = (output, context) => {
6189
- return {
6190
- Name: __expectString(output.Name),
6191
- WebACLId: __expectString(output.WebACLId),
6192
- };
6193
- };
6194
- const de_XssMatchSet = (output, context) => {
6195
- return {
6196
- Name: __expectString(output.Name),
6197
- XssMatchSetId: __expectString(output.XssMatchSetId),
6198
- XssMatchTuples: output.XssMatchTuples != null ? de_XssMatchTuples(output.XssMatchTuples, context) : undefined,
6199
- };
6200
4290
  };
6201
- const de_XssMatchSetSummaries = (output, context) => {
4291
+ const de_SampledHTTPRequests = (output, context) => {
6202
4292
  const retVal = (output || [])
6203
4293
  .filter((e) => e != null)
6204
4294
  .map((entry) => {
6205
- if (entry === null) {
6206
- return null;
6207
- }
6208
- return de_XssMatchSetSummary(entry, context);
4295
+ return de_SampledHTTPRequest(entry, context);
6209
4296
  });
6210
4297
  return retVal;
6211
4298
  };
6212
- const de_XssMatchSetSummary = (output, context) => {
6213
- return {
6214
- Name: __expectString(output.Name),
6215
- XssMatchSetId: __expectString(output.XssMatchSetId),
6216
- };
6217
- };
6218
- const de_XssMatchTuple = (output, context) => {
6219
- return {
6220
- FieldToMatch: output.FieldToMatch != null ? de_FieldToMatch(output.FieldToMatch, context) : undefined,
6221
- TextTransformation: __expectString(output.TextTransformation),
6222
- };
6223
- };
6224
- const de_XssMatchTuples = (output, context) => {
6225
- const retVal = (output || [])
6226
- .filter((e) => e != null)
6227
- .map((entry) => {
6228
- if (entry === null) {
6229
- return null;
6230
- }
6231
- return de_XssMatchTuple(entry, context);
4299
+ const de_TimeWindow = (output, context) => {
4300
+ return take(output, {
4301
+ EndTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
4302
+ StartTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
6232
4303
  });
6233
- return retVal;
6234
4304
  };
6235
4305
  const deserializeMetadata = (output) => ({
6236
4306
  httpStatusCode: output.statusCode,
@@ -6245,6 +4315,7 @@ const collectBody = (streamBody = new Uint8Array(), context) => {
6245
4315
  return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
6246
4316
  };
6247
4317
  const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
4318
+ const throwDefaultError = withBaseException(__BaseException);
6248
4319
  const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
6249
4320
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
6250
4321
  const contents = {