@aws-sdk/client-frauddetector 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 +472 -2438
  2. package/dist-es/protocols/Aws_json1_1.js +473 -2439
  3. package/package.json +6 -6
package/dist-es/protocols/Aws_json1_1.js CHANGED
@@ -1,227 +1,227 @@
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, expectString as __expectString, limitedParseFloat32 as __limitedParseFloat32, throwDefaultError, } from "@aws-sdk/smithy-client";
2
+ import { _json, decorateServiceException as __decorateServiceException, expectString as __expectString, limitedParseFloat32 as __limitedParseFloat32, take, withBaseException, } from "@aws-sdk/smithy-client";
3
3
  import { FraudDetectorServiceException as __BaseException } from "../models/FraudDetectorServiceException";
4
4
  import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ResourceUnavailableException, ThrottlingException, ValidationException, } from "../models/models_0";
5
5
  export const se_BatchCreateVariableCommand = async (input, context) => {
6
6
  const headers = sharedHeaders("BatchCreateVariable");
7
7
  let body;
8
- body = JSON.stringify(se_BatchCreateVariableRequest(input, context));
8
+ body = JSON.stringify(_json(input));
9
9
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
10
10
  };
11
11
  export const se_BatchGetVariableCommand = async (input, context) => {
12
12
  const headers = sharedHeaders("BatchGetVariable");
13
13
  let body;
14
- body = JSON.stringify(se_BatchGetVariableRequest(input, context));
14
+ body = JSON.stringify(_json(input));
15
15
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
16
16
  };
17
17
  export const se_CancelBatchImportJobCommand = async (input, context) => {
18
18
  const headers = sharedHeaders("CancelBatchImportJob");
19
19
  let body;
20
- body = JSON.stringify(se_CancelBatchImportJobRequest(input, context));
20
+ body = JSON.stringify(_json(input));
21
21
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
22
22
  };
23
23
  export const se_CancelBatchPredictionJobCommand = async (input, context) => {
24
24
  const headers = sharedHeaders("CancelBatchPredictionJob");
25
25
  let body;
26
- body = JSON.stringify(se_CancelBatchPredictionJobRequest(input, context));
26
+ body = JSON.stringify(_json(input));
27
27
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
28
28
  };
29
29
  export const se_CreateBatchImportJobCommand = async (input, context) => {
30
30
  const headers = sharedHeaders("CreateBatchImportJob");
31
31
  let body;
32
- body = JSON.stringify(se_CreateBatchImportJobRequest(input, context));
32
+ body = JSON.stringify(_json(input));
33
33
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
34
34
  };
35
35
  export const se_CreateBatchPredictionJobCommand = async (input, context) => {
36
36
  const headers = sharedHeaders("CreateBatchPredictionJob");
37
37
  let body;
38
- body = JSON.stringify(se_CreateBatchPredictionJobRequest(input, context));
38
+ body = JSON.stringify(_json(input));
39
39
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
40
40
  };
41
41
  export const se_CreateDetectorVersionCommand = async (input, context) => {
42
42
  const headers = sharedHeaders("CreateDetectorVersion");
43
43
  let body;
44
- body = JSON.stringify(se_CreateDetectorVersionRequest(input, context));
44
+ body = JSON.stringify(_json(input));
45
45
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
46
46
  };
47
47
  export const se_CreateListCommand = async (input, context) => {
48
48
  const headers = sharedHeaders("CreateList");
49
49
  let body;
50
- body = JSON.stringify(se_CreateListRequest(input, context));
50
+ body = JSON.stringify(_json(input));
51
51
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
52
52
  };
53
53
  export const se_CreateModelCommand = async (input, context) => {
54
54
  const headers = sharedHeaders("CreateModel");
55
55
  let body;
56
- body = JSON.stringify(se_CreateModelRequest(input, context));
56
+ body = JSON.stringify(_json(input));
57
57
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
58
58
  };
59
59
  export const se_CreateModelVersionCommand = async (input, context) => {
60
60
  const headers = sharedHeaders("CreateModelVersion");
61
61
  let body;
62
- body = JSON.stringify(se_CreateModelVersionRequest(input, context));
62
+ body = JSON.stringify(_json(input));
63
63
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
64
64
  };
65
65
  export const se_CreateRuleCommand = async (input, context) => {
66
66
  const headers = sharedHeaders("CreateRule");
67
67
  let body;
68
- body = JSON.stringify(se_CreateRuleRequest(input, context));
68
+ body = JSON.stringify(_json(input));
69
69
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
70
70
  };
71
71
  export const se_CreateVariableCommand = async (input, context) => {
72
72
  const headers = sharedHeaders("CreateVariable");
73
73
  let body;
74
- body = JSON.stringify(se_CreateVariableRequest(input, context));
74
+ body = JSON.stringify(_json(input));
75
75
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
76
76
  };
77
77
  export const se_DeleteBatchImportJobCommand = async (input, context) => {
78
78
  const headers = sharedHeaders("DeleteBatchImportJob");
79
79
  let body;
80
- body = JSON.stringify(se_DeleteBatchImportJobRequest(input, context));
80
+ body = JSON.stringify(_json(input));
81
81
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
82
82
  };
83
83
  export const se_DeleteBatchPredictionJobCommand = async (input, context) => {
84
84
  const headers = sharedHeaders("DeleteBatchPredictionJob");
85
85
  let body;
86
- body = JSON.stringify(se_DeleteBatchPredictionJobRequest(input, context));
86
+ body = JSON.stringify(_json(input));
87
87
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
88
88
  };
89
89
  export const se_DeleteDetectorCommand = async (input, context) => {
90
90
  const headers = sharedHeaders("DeleteDetector");
91
91
  let body;
92
- body = JSON.stringify(se_DeleteDetectorRequest(input, context));
92
+ body = JSON.stringify(_json(input));
93
93
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
94
94
  };
95
95
  export const se_DeleteDetectorVersionCommand = async (input, context) => {
96
96
  const headers = sharedHeaders("DeleteDetectorVersion");
97
97
  let body;
98
- body = JSON.stringify(se_DeleteDetectorVersionRequest(input, context));
98
+ body = JSON.stringify(_json(input));
99
99
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
100
100
  };
101
101
  export const se_DeleteEntityTypeCommand = async (input, context) => {
102
102
  const headers = sharedHeaders("DeleteEntityType");
103
103
  let body;
104
- body = JSON.stringify(se_DeleteEntityTypeRequest(input, context));
104
+ body = JSON.stringify(_json(input));
105
105
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
106
106
  };
107
107
  export const se_DeleteEventCommand = async (input, context) => {
108
108
  const headers = sharedHeaders("DeleteEvent");
109
109
  let body;
110
- body = JSON.stringify(se_DeleteEventRequest(input, context));
110
+ body = JSON.stringify(_json(input));
111
111
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
112
112
  };
113
113
  export const se_DeleteEventsByEventTypeCommand = async (input, context) => {
114
114
  const headers = sharedHeaders("DeleteEventsByEventType");
115
115
  let body;
116
- body = JSON.stringify(se_DeleteEventsByEventTypeRequest(input, context));
116
+ body = JSON.stringify(_json(input));
117
117
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
118
118
  };
119
119
  export const se_DeleteEventTypeCommand = async (input, context) => {
120
120
  const headers = sharedHeaders("DeleteEventType");
121
121
  let body;
122
- body = JSON.stringify(se_DeleteEventTypeRequest(input, context));
122
+ body = JSON.stringify(_json(input));
123
123
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
124
124
  };
125
125
  export const se_DeleteExternalModelCommand = async (input, context) => {
126
126
  const headers = sharedHeaders("DeleteExternalModel");
127
127
  let body;
128
- body = JSON.stringify(se_DeleteExternalModelRequest(input, context));
128
+ body = JSON.stringify(_json(input));
129
129
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
130
130
  };
131
131
  export const se_DeleteLabelCommand = async (input, context) => {
132
132
  const headers = sharedHeaders("DeleteLabel");
133
133
  let body;
134
- body = JSON.stringify(se_DeleteLabelRequest(input, context));
134
+ body = JSON.stringify(_json(input));
135
135
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
136
136
  };
137
137
  export const se_DeleteListCommand = async (input, context) => {
138
138
  const headers = sharedHeaders("DeleteList");
139
139
  let body;
140
- body = JSON.stringify(se_DeleteListRequest(input, context));
140
+ body = JSON.stringify(_json(input));
141
141
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
142
142
  };
143
143
  export const se_DeleteModelCommand = async (input, context) => {
144
144
  const headers = sharedHeaders("DeleteModel");
145
145
  let body;
146
- body = JSON.stringify(se_DeleteModelRequest(input, context));
146
+ body = JSON.stringify(_json(input));
147
147
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
148
148
  };
149
149
  export const se_DeleteModelVersionCommand = async (input, context) => {
150
150
  const headers = sharedHeaders("DeleteModelVersion");
151
151
  let body;
152
- body = JSON.stringify(se_DeleteModelVersionRequest(input, context));
152
+ body = JSON.stringify(_json(input));
153
153
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
154
154
  };
155
155
  export const se_DeleteOutcomeCommand = async (input, context) => {
156
156
  const headers = sharedHeaders("DeleteOutcome");
157
157
  let body;
158
- body = JSON.stringify(se_DeleteOutcomeRequest(input, context));
158
+ body = JSON.stringify(_json(input));
159
159
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
160
160
  };
161
161
  export const se_DeleteRuleCommand = async (input, context) => {
162
162
  const headers = sharedHeaders("DeleteRule");
163
163
  let body;
164
- body = JSON.stringify(se_DeleteRuleRequest(input, context));
164
+ body = JSON.stringify(_json(input));
165
165
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
166
166
  };
167
167
  export const se_DeleteVariableCommand = async (input, context) => {
168
168
  const headers = sharedHeaders("DeleteVariable");
169
169
  let body;
170
- body = JSON.stringify(se_DeleteVariableRequest(input, context));
170
+ body = JSON.stringify(_json(input));
171
171
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
172
172
  };
173
173
  export const se_DescribeDetectorCommand = async (input, context) => {
174
174
  const headers = sharedHeaders("DescribeDetector");
175
175
  let body;
176
- body = JSON.stringify(se_DescribeDetectorRequest(input, context));
176
+ body = JSON.stringify(_json(input));
177
177
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
178
178
  };
179
179
  export const se_DescribeModelVersionsCommand = async (input, context) => {
180
180
  const headers = sharedHeaders("DescribeModelVersions");
181
181
  let body;
182
- body = JSON.stringify(se_DescribeModelVersionsRequest(input, context));
182
+ body = JSON.stringify(_json(input));
183
183
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
184
184
  };
185
185
  export const se_GetBatchImportJobsCommand = async (input, context) => {
186
186
  const headers = sharedHeaders("GetBatchImportJobs");
187
187
  let body;
188
- body = JSON.stringify(se_GetBatchImportJobsRequest(input, context));
188
+ body = JSON.stringify(_json(input));
189
189
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
190
190
  };
191
191
  export const se_GetBatchPredictionJobsCommand = async (input, context) => {
192
192
  const headers = sharedHeaders("GetBatchPredictionJobs");
193
193
  let body;
194
- body = JSON.stringify(se_GetBatchPredictionJobsRequest(input, context));
194
+ body = JSON.stringify(_json(input));
195
195
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
196
196
  };
197
197
  export const se_GetDeleteEventsByEventTypeStatusCommand = async (input, context) => {
198
198
  const headers = sharedHeaders("GetDeleteEventsByEventTypeStatus");
199
199
  let body;
200
- body = JSON.stringify(se_GetDeleteEventsByEventTypeStatusRequest(input, context));
200
+ body = JSON.stringify(_json(input));
201
201
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
202
202
  };
203
203
  export const se_GetDetectorsCommand = async (input, context) => {
204
204
  const headers = sharedHeaders("GetDetectors");
205
205
  let body;
206
- body = JSON.stringify(se_GetDetectorsRequest(input, context));
206
+ body = JSON.stringify(_json(input));
207
207
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
208
208
  };
209
209
  export const se_GetDetectorVersionCommand = async (input, context) => {
210
210
  const headers = sharedHeaders("GetDetectorVersion");
211
211
  let body;
212
- body = JSON.stringify(se_GetDetectorVersionRequest(input, context));
212
+ body = JSON.stringify(_json(input));
213
213
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
214
214
  };
215
215
  export const se_GetEntityTypesCommand = async (input, context) => {
216
216
  const headers = sharedHeaders("GetEntityTypes");
217
217
  let body;
218
- body = JSON.stringify(se_GetEntityTypesRequest(input, context));
218
+ body = JSON.stringify(_json(input));
219
219
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
220
220
  };
221
221
  export const se_GetEventCommand = async (input, context) => {
222
222
  const headers = sharedHeaders("GetEvent");
223
223
  let body;
224
- body = JSON.stringify(se_GetEventRequest(input, context));
224
+ body = JSON.stringify(_json(input));
225
225
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
226
226
  };
227
227
  export const se_GetEventPredictionCommand = async (input, context) => {
@@ -233,19 +233,19 @@ export const se_GetEventPredictionCommand = async (input, context) => {
233
233
  export const se_GetEventPredictionMetadataCommand = async (input, context) => {
234
234
  const headers = sharedHeaders("GetEventPredictionMetadata");
235
235
  let body;
236
- body = JSON.stringify(se_GetEventPredictionMetadataRequest(input, context));
236
+ body = JSON.stringify(_json(input));
237
237
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
238
238
  };
239
239
  export const se_GetEventTypesCommand = async (input, context) => {
240
240
  const headers = sharedHeaders("GetEventTypes");
241
241
  let body;
242
- body = JSON.stringify(se_GetEventTypesRequest(input, context));
242
+ body = JSON.stringify(_json(input));
243
243
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
244
244
  };
245
245
  export const se_GetExternalModelsCommand = async (input, context) => {
246
246
  const headers = sharedHeaders("GetExternalModels");
247
247
  let body;
248
- body = JSON.stringify(se_GetExternalModelsRequest(input, context));
248
+ body = JSON.stringify(_json(input));
249
249
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
250
250
  };
251
251
  export const se_GetKMSEncryptionKeyCommand = async (input, context) => {
@@ -256,187 +256,187 @@ export const se_GetKMSEncryptionKeyCommand = async (input, context) => {
256
256
  export const se_GetLabelsCommand = async (input, context) => {
257
257
  const headers = sharedHeaders("GetLabels");
258
258
  let body;
259
- body = JSON.stringify(se_GetLabelsRequest(input, context));
259
+ body = JSON.stringify(_json(input));
260
260
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
261
261
  };
262
262
  export const se_GetListElementsCommand = async (input, context) => {
263
263
  const headers = sharedHeaders("GetListElements");
264
264
  let body;
265
- body = JSON.stringify(se_GetListElementsRequest(input, context));
265
+ body = JSON.stringify(_json(input));
266
266
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
267
267
  };
268
268
  export const se_GetListsMetadataCommand = async (input, context) => {
269
269
  const headers = sharedHeaders("GetListsMetadata");
270
270
  let body;
271
- body = JSON.stringify(se_GetListsMetadataRequest(input, context));
271
+ body = JSON.stringify(_json(input));
272
272
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
273
273
  };
274
274
  export const se_GetModelsCommand = async (input, context) => {
275
275
  const headers = sharedHeaders("GetModels");
276
276
  let body;
277
- body = JSON.stringify(se_GetModelsRequest(input, context));
277
+ body = JSON.stringify(_json(input));
278
278
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
279
279
  };
280
280
  export const se_GetModelVersionCommand = async (input, context) => {
281
281
  const headers = sharedHeaders("GetModelVersion");
282
282
  let body;
283
- body = JSON.stringify(se_GetModelVersionRequest(input, context));
283
+ body = JSON.stringify(_json(input));
284
284
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
285
285
  };
286
286
  export const se_GetOutcomesCommand = async (input, context) => {
287
287
  const headers = sharedHeaders("GetOutcomes");
288
288
  let body;
289
- body = JSON.stringify(se_GetOutcomesRequest(input, context));
289
+ body = JSON.stringify(_json(input));
290
290
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
291
291
  };
292
292
  export const se_GetRulesCommand = async (input, context) => {
293
293
  const headers = sharedHeaders("GetRules");
294
294
  let body;
295
- body = JSON.stringify(se_GetRulesRequest(input, context));
295
+ body = JSON.stringify(_json(input));
296
296
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
297
297
  };
298
298
  export const se_GetVariablesCommand = async (input, context) => {
299
299
  const headers = sharedHeaders("GetVariables");
300
300
  let body;
301
- body = JSON.stringify(se_GetVariablesRequest(input, context));
301
+ body = JSON.stringify(_json(input));
302
302
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
303
303
  };
304
304
  export const se_ListEventPredictionsCommand = async (input, context) => {
305
305
  const headers = sharedHeaders("ListEventPredictions");
306
306
  let body;
307
- body = JSON.stringify(se_ListEventPredictionsRequest(input, context));
307
+ body = JSON.stringify(_json(input));
308
308
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
309
309
  };
310
310
  export const se_ListTagsForResourceCommand = async (input, context) => {
311
311
  const headers = sharedHeaders("ListTagsForResource");
312
312
  let body;
313
- body = JSON.stringify(se_ListTagsForResourceRequest(input, context));
313
+ body = JSON.stringify(_json(input));
314
314
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
315
315
  };
316
316
  export const se_PutDetectorCommand = async (input, context) => {
317
317
  const headers = sharedHeaders("PutDetector");
318
318
  let body;
319
- body = JSON.stringify(se_PutDetectorRequest(input, context));
319
+ body = JSON.stringify(_json(input));
320
320
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
321
321
  };
322
322
  export const se_PutEntityTypeCommand = async (input, context) => {
323
323
  const headers = sharedHeaders("PutEntityType");
324
324
  let body;
325
- body = JSON.stringify(se_PutEntityTypeRequest(input, context));
325
+ body = JSON.stringify(_json(input));
326
326
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
327
327
  };
328
328
  export const se_PutEventTypeCommand = async (input, context) => {
329
329
  const headers = sharedHeaders("PutEventType");
330
330
  let body;
331
- body = JSON.stringify(se_PutEventTypeRequest(input, context));
331
+ body = JSON.stringify(_json(input));
332
332
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
333
333
  };
334
334
  export const se_PutExternalModelCommand = async (input, context) => {
335
335
  const headers = sharedHeaders("PutExternalModel");
336
336
  let body;
337
- body = JSON.stringify(se_PutExternalModelRequest(input, context));
337
+ body = JSON.stringify(_json(input));
338
338
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
339
339
  };
340
340
  export const se_PutKMSEncryptionKeyCommand = async (input, context) => {
341
341
  const headers = sharedHeaders("PutKMSEncryptionKey");
342
342
  let body;
343
- body = JSON.stringify(se_PutKMSEncryptionKeyRequest(input, context));
343
+ body = JSON.stringify(_json(input));
344
344
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
345
345
  };
346
346
  export const se_PutLabelCommand = async (input, context) => {
347
347
  const headers = sharedHeaders("PutLabel");
348
348
  let body;
349
- body = JSON.stringify(se_PutLabelRequest(input, context));
349
+ body = JSON.stringify(_json(input));
350
350
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
351
351
  };
352
352
  export const se_PutOutcomeCommand = async (input, context) => {
353
353
  const headers = sharedHeaders("PutOutcome");
354
354
  let body;
355
- body = JSON.stringify(se_PutOutcomeRequest(input, context));
355
+ body = JSON.stringify(_json(input));
356
356
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
357
357
  };
358
358
  export const se_SendEventCommand = async (input, context) => {
359
359
  const headers = sharedHeaders("SendEvent");
360
360
  let body;
361
- body = JSON.stringify(se_SendEventRequest(input, context));
361
+ body = JSON.stringify(_json(input));
362
362
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
363
363
  };
364
364
  export const se_TagResourceCommand = async (input, context) => {
365
365
  const headers = sharedHeaders("TagResource");
366
366
  let body;
367
- body = JSON.stringify(se_TagResourceRequest(input, context));
367
+ body = JSON.stringify(_json(input));
368
368
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
369
369
  };
370
370
  export const se_UntagResourceCommand = async (input, context) => {
371
371
  const headers = sharedHeaders("UntagResource");
372
372
  let body;
373
- body = JSON.stringify(se_UntagResourceRequest(input, context));
373
+ body = JSON.stringify(_json(input));
374
374
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
375
375
  };
376
376
  export const se_UpdateDetectorVersionCommand = async (input, context) => {
377
377
  const headers = sharedHeaders("UpdateDetectorVersion");
378
378
  let body;
379
- body = JSON.stringify(se_UpdateDetectorVersionRequest(input, context));
379
+ body = JSON.stringify(_json(input));
380
380
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
381
381
  };
382
382
  export const se_UpdateDetectorVersionMetadataCommand = async (input, context) => {
383
383
  const headers = sharedHeaders("UpdateDetectorVersionMetadata");
384
384
  let body;
385
- body = JSON.stringify(se_UpdateDetectorVersionMetadataRequest(input, context));
385
+ body = JSON.stringify(_json(input));
386
386
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
387
387
  };
388
388
  export const se_UpdateDetectorVersionStatusCommand = async (input, context) => {
389
389
  const headers = sharedHeaders("UpdateDetectorVersionStatus");
390
390
  let body;
391
- body = JSON.stringify(se_UpdateDetectorVersionStatusRequest(input, context));
391
+ body = JSON.stringify(_json(input));
392
392
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
393
393
  };
394
394
  export const se_UpdateEventLabelCommand = async (input, context) => {
395
395
  const headers = sharedHeaders("UpdateEventLabel");
396
396
  let body;
397
- body = JSON.stringify(se_UpdateEventLabelRequest(input, context));
397
+ body = JSON.stringify(_json(input));
398
398
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
399
399
  };
400
400
  export const se_UpdateListCommand = async (input, context) => {
401
401
  const headers = sharedHeaders("UpdateList");
402
402
  let body;
403
- body = JSON.stringify(se_UpdateListRequest(input, context));
403
+ body = JSON.stringify(_json(input));
404
404
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
405
405
  };
406
406
  export const se_UpdateModelCommand = async (input, context) => {
407
407
  const headers = sharedHeaders("UpdateModel");
408
408
  let body;
409
- body = JSON.stringify(se_UpdateModelRequest(input, context));
409
+ body = JSON.stringify(_json(input));
410
410
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
411
411
  };
412
412
  export const se_UpdateModelVersionCommand = async (input, context) => {
413
413
  const headers = sharedHeaders("UpdateModelVersion");
414
414
  let body;
415
- body = JSON.stringify(se_UpdateModelVersionRequest(input, context));
415
+ body = JSON.stringify(_json(input));
416
416
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
417
417
  };
418
418
  export const se_UpdateModelVersionStatusCommand = async (input, context) => {
419
419
  const headers = sharedHeaders("UpdateModelVersionStatus");
420
420
  let body;
421
- body = JSON.stringify(se_UpdateModelVersionStatusRequest(input, context));
421
+ body = JSON.stringify(_json(input));
422
422
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
423
423
  };
424
424
  export const se_UpdateRuleMetadataCommand = async (input, context) => {
425
425
  const headers = sharedHeaders("UpdateRuleMetadata");
426
426
  let body;
427
- body = JSON.stringify(se_UpdateRuleMetadataRequest(input, context));
427
+ body = JSON.stringify(_json(input));
428
428
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
429
429
  };
430
430
  export const se_UpdateRuleVersionCommand = async (input, context) => {
431
431
  const headers = sharedHeaders("UpdateRuleVersion");
432
432
  let body;
433
- body = JSON.stringify(se_UpdateRuleVersionRequest(input, context));
433
+ body = JSON.stringify(_json(input));
434
434
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
435
435
  };
436
436
  export const se_UpdateVariableCommand = async (input, context) => {
437
437
  const headers = sharedHeaders("UpdateVariable");
438
438
  let body;
439
- body = JSON.stringify(se_UpdateVariableRequest(input, context));
439
+ body = JSON.stringify(_json(input));
440
440
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
441
441
  };
442
442
  export const de_BatchCreateVariableCommand = async (output, context) => {
@@ -445,12 +445,12 @@ export const de_BatchCreateVariableCommand = async (output, context) => {
445
445
  }
446
446
  const data = await parseBody(output.body, context);
447
447
  let contents = {};
448
- contents = de_BatchCreateVariableResult(data, context);
448
+ contents = _json(data);
449
449
  const response = {
450
450
  $metadata: deserializeMetadata(output),
451
451
  ...contents,
452
452
  };
453
- return Promise.resolve(response);
453
+ return response;
454
454
  };
455
455
  const de_BatchCreateVariableCommandError = async (output, context) => {
456
456
  const parsedOutput = {
@@ -473,10 +473,9 @@ const de_BatchCreateVariableCommandError = async (output, context) => {
473
473
  throw await de_ValidationExceptionRes(parsedOutput, context);
474
474
  default:
475
475
  const parsedBody = parsedOutput.body;
476
- throwDefaultError({
476
+ return throwDefaultError({
477
477
  output,
478
478
  parsedBody,
479
- exceptionCtor: __BaseException,
480
479
  errorCode,
481
480
  });
482
481
  }
@@ -487,12 +486,12 @@ export const de_BatchGetVariableCommand = async (output, context) => {
487
486
  }
488
487
  const data = await parseBody(output.body, context);
489
488
  let contents = {};
490
- contents = de_BatchGetVariableResult(data, context);
489
+ contents = _json(data);
491
490
  const response = {
492
491
  $metadata: deserializeMetadata(output),
493
492
  ...contents,
494
493
  };
495
- return Promise.resolve(response);
494
+ return response;
496
495
  };
497
496
  const de_BatchGetVariableCommandError = async (output, context) => {
498
497
  const parsedOutput = {
@@ -515,10 +514,9 @@ const de_BatchGetVariableCommandError = async (output, context) => {
515
514
  throw await de_ValidationExceptionRes(parsedOutput, context);
516
515
  default:
517
516
  const parsedBody = parsedOutput.body;
518
- throwDefaultError({
517
+ return throwDefaultError({
519
518
  output,
520
519
  parsedBody,
521
- exceptionCtor: __BaseException,
522
520
  errorCode,
523
521
  });
524
522
  }
@@ -529,12 +527,12 @@ export const de_CancelBatchImportJobCommand = async (output, context) => {
529
527
  }
530
528
  const data = await parseBody(output.body, context);
531
529
  let contents = {};
532
- contents = de_CancelBatchImportJobResult(data, context);
530
+ contents = _json(data);
533
531
  const response = {
534
532
  $metadata: deserializeMetadata(output),
535
533
  ...contents,
536
534
  };
537
- return Promise.resolve(response);
535
+ return response;
538
536
  };
539
537
  const de_CancelBatchImportJobCommandError = async (output, context) => {
540
538
  const parsedOutput = {
@@ -560,10 +558,9 @@ const de_CancelBatchImportJobCommandError = async (output, context) => {
560
558
  throw await de_ValidationExceptionRes(parsedOutput, context);
561
559
  default:
562
560
  const parsedBody = parsedOutput.body;
563
- throwDefaultError({
561
+ return throwDefaultError({
564
562
  output,
565
563
  parsedBody,
566
- exceptionCtor: __BaseException,
567
564
  errorCode,
568
565
  });
569
566
  }
@@ -574,12 +571,12 @@ export const de_CancelBatchPredictionJobCommand = async (output, context) => {
574
571
  }
575
572
  const data = await parseBody(output.body, context);
576
573
  let contents = {};
577
- contents = de_CancelBatchPredictionJobResult(data, context);
574
+ contents = _json(data);
578
575
  const response = {
579
576
  $metadata: deserializeMetadata(output),
580
577
  ...contents,
581
578
  };
582
- return Promise.resolve(response);
579
+ return response;
583
580
  };
584
581
  const de_CancelBatchPredictionJobCommandError = async (output, context) => {
585
582
  const parsedOutput = {
@@ -605,10 +602,9 @@ const de_CancelBatchPredictionJobCommandError = async (output, context) => {
605
602
  throw await de_ValidationExceptionRes(parsedOutput, context);
606
603
  default:
607
604
  const parsedBody = parsedOutput.body;
608
- throwDefaultError({
605
+ return throwDefaultError({
609
606
  output,
610
607
  parsedBody,
611
- exceptionCtor: __BaseException,
612
608
  errorCode,
613
609
  });
614
610
  }
@@ -619,12 +615,12 @@ export const de_CreateBatchImportJobCommand = async (output, context) => {
619
615
  }
620
616
  const data = await parseBody(output.body, context);
621
617
  let contents = {};
622
- contents = de_CreateBatchImportJobResult(data, context);
618
+ contents = _json(data);
623
619
  const response = {
624
620
  $metadata: deserializeMetadata(output),
625
621
  ...contents,
626
622
  };
627
- return Promise.resolve(response);
623
+ return response;
628
624
  };
629
625
  const de_CreateBatchImportJobCommandError = async (output, context) => {
630
626
  const parsedOutput = {
@@ -650,10 +646,9 @@ const de_CreateBatchImportJobCommandError = async (output, context) => {
650
646
  throw await de_ValidationExceptionRes(parsedOutput, context);
651
647
  default:
652
648
  const parsedBody = parsedOutput.body;
653
- throwDefaultError({
649
+ return throwDefaultError({
654
650
  output,
655
651
  parsedBody,
656
- exceptionCtor: __BaseException,
657
652
  errorCode,
658
653
  });
659
654
  }
@@ -664,12 +659,12 @@ export const de_CreateBatchPredictionJobCommand = async (output, context) => {
664
659
  }
665
660
  const data = await parseBody(output.body, context);
666
661
  let contents = {};
667
- contents = de_CreateBatchPredictionJobResult(data, context);
662
+ contents = _json(data);
668
663
  const response = {
669
664
  $metadata: deserializeMetadata(output),
670
665
  ...contents,
671
666
  };
672
- return Promise.resolve(response);
667
+ return response;
673
668
  };
674
669
  const de_CreateBatchPredictionJobCommandError = async (output, context) => {
675
670
  const parsedOutput = {
@@ -695,10 +690,9 @@ const de_CreateBatchPredictionJobCommandError = async (output, context) => {
695
690
  throw await de_ValidationExceptionRes(parsedOutput, context);
696
691
  default:
697
692
  const parsedBody = parsedOutput.body;
698
- throwDefaultError({
693
+ return throwDefaultError({
699
694
  output,
700
695
  parsedBody,
701
- exceptionCtor: __BaseException,
702
696
  errorCode,
703
697
  });
704
698
  }
@@ -709,12 +703,12 @@ export const de_CreateDetectorVersionCommand = async (output, context) => {
709
703
  }
710
704
  const data = await parseBody(output.body, context);
711
705
  let contents = {};
712
- contents = de_CreateDetectorVersionResult(data, context);
706
+ contents = _json(data);
713
707
  const response = {
714
708
  $metadata: deserializeMetadata(output),
715
709
  ...contents,
716
710
  };
717
- return Promise.resolve(response);
711
+ return response;
718
712
  };
719
713
  const de_CreateDetectorVersionCommandError = async (output, context) => {
720
714
  const parsedOutput = {
@@ -740,10 +734,9 @@ const de_CreateDetectorVersionCommandError = async (output, context) => {
740
734
  throw await de_ValidationExceptionRes(parsedOutput, context);
741
735
  default:
742
736
  const parsedBody = parsedOutput.body;
743
- throwDefaultError({
737
+ return throwDefaultError({
744
738
  output,
745
739
  parsedBody,
746
- exceptionCtor: __BaseException,
747
740
  errorCode,
748
741
  });
749
742
  }
@@ -754,12 +747,12 @@ export const de_CreateListCommand = async (output, context) => {
754
747
  }
755
748
  const data = await parseBody(output.body, context);
756
749
  let contents = {};
757
- contents = de_CreateListResult(data, context);
750
+ contents = _json(data);
758
751
  const response = {
759
752
  $metadata: deserializeMetadata(output),
760
753
  ...contents,
761
754
  };
762
- return Promise.resolve(response);
755
+ return response;
763
756
  };
764
757
  const de_CreateListCommandError = async (output, context) => {
765
758
  const parsedOutput = {
@@ -782,10 +775,9 @@ const de_CreateListCommandError = async (output, context) => {
782
775
  throw await de_ValidationExceptionRes(parsedOutput, context);
783
776
  default:
784
777
  const parsedBody = parsedOutput.body;
785
- throwDefaultError({
778
+ return throwDefaultError({
786
779
  output,
787
780
  parsedBody,
788
- exceptionCtor: __BaseException,
789
781
  errorCode,
790
782
  });
791
783
  }
@@ -796,12 +788,12 @@ export const de_CreateModelCommand = async (output, context) => {
796
788
  }
797
789
  const data = await parseBody(output.body, context);
798
790
  let contents = {};
799
- contents = de_CreateModelResult(data, context);
791
+ contents = _json(data);
800
792
  const response = {
801
793
  $metadata: deserializeMetadata(output),
802
794
  ...contents,
803
795
  };
804
- return Promise.resolve(response);
796
+ return response;
805
797
  };
806
798
  const de_CreateModelCommandError = async (output, context) => {
807
799
  const parsedOutput = {
@@ -824,10 +816,9 @@ const de_CreateModelCommandError = async (output, context) => {
824
816
  throw await de_ValidationExceptionRes(parsedOutput, context);
825
817
  default:
826
818
  const parsedBody = parsedOutput.body;
827
- throwDefaultError({
819
+ return throwDefaultError({
828
820
  output,
829
821
  parsedBody,
830
- exceptionCtor: __BaseException,
831
822
  errorCode,
832
823
  });
833
824
  }
@@ -838,12 +829,12 @@ export const de_CreateModelVersionCommand = async (output, context) => {
838
829
  }
839
830
  const data = await parseBody(output.body, context);
840
831
  let contents = {};
841
- contents = de_CreateModelVersionResult(data, context);
832
+ contents = _json(data);
842
833
  const response = {
843
834
  $metadata: deserializeMetadata(output),
844
835
  ...contents,
845
836
  };
846
- return Promise.resolve(response);
837
+ return response;
847
838
  };
848
839
  const de_CreateModelVersionCommandError = async (output, context) => {
849
840
  const parsedOutput = {
@@ -869,10 +860,9 @@ const de_CreateModelVersionCommandError = async (output, context) => {
869
860
  throw await de_ValidationExceptionRes(parsedOutput, context);
870
861
  default:
871
862
  const parsedBody = parsedOutput.body;
872
- throwDefaultError({
863
+ return throwDefaultError({
873
864
  output,
874
865
  parsedBody,
875
- exceptionCtor: __BaseException,
876
866
  errorCode,
877
867
  });
878
868
  }
@@ -883,12 +873,12 @@ export const de_CreateRuleCommand = async (output, context) => {
883
873
  }
884
874
  const data = await parseBody(output.body, context);
885
875
  let contents = {};
886
- contents = de_CreateRuleResult(data, context);
876
+ contents = _json(data);
887
877
  const response = {
888
878
  $metadata: deserializeMetadata(output),
889
879
  ...contents,
890
880
  };
891
- return Promise.resolve(response);
881
+ return response;
892
882
  };
893
883
  const de_CreateRuleCommandError = async (output, context) => {
894
884
  const parsedOutput = {
@@ -911,10 +901,9 @@ const de_CreateRuleCommandError = async (output, context) => {
911
901
  throw await de_ValidationExceptionRes(parsedOutput, context);
912
902
  default:
913
903
  const parsedBody = parsedOutput.body;
914
- throwDefaultError({
904
+ return throwDefaultError({
915
905
  output,
916
906
  parsedBody,
917
- exceptionCtor: __BaseException,
918
907
  errorCode,
919
908
  });
920
909
  }
@@ -925,12 +914,12 @@ export const de_CreateVariableCommand = async (output, context) => {
925
914
  }
926
915
  const data = await parseBody(output.body, context);
927
916
  let contents = {};
928
- contents = de_CreateVariableResult(data, context);
917
+ contents = _json(data);
929
918
  const response = {
930
919
  $metadata: deserializeMetadata(output),
931
920
  ...contents,
932
921
  };
933
- return Promise.resolve(response);
922
+ return response;
934
923
  };
935
924
  const de_CreateVariableCommandError = async (output, context) => {
936
925
  const parsedOutput = {
@@ -953,10 +942,9 @@ const de_CreateVariableCommandError = async (output, context) => {
953
942
  throw await de_ValidationExceptionRes(parsedOutput, context);
954
943
  default:
955
944
  const parsedBody = parsedOutput.body;
956
- throwDefaultError({
945
+ return throwDefaultError({
957
946
  output,
958
947
  parsedBody,
959
- exceptionCtor: __BaseException,
960
948
  errorCode,
961
949
  });
962
950
  }
@@ -967,12 +955,12 @@ export const de_DeleteBatchImportJobCommand = async (output, context) => {
967
955
  }
968
956
  const data = await parseBody(output.body, context);
969
957
  let contents = {};
970
- contents = de_DeleteBatchImportJobResult(data, context);
958
+ contents = _json(data);
971
959
  const response = {
972
960
  $metadata: deserializeMetadata(output),
973
961
  ...contents,
974
962
  };
975
- return Promise.resolve(response);
963
+ return response;
976
964
  };
977
965
  const de_DeleteBatchImportJobCommandError = async (output, context) => {
978
966
  const parsedOutput = {
@@ -995,10 +983,9 @@ const de_DeleteBatchImportJobCommandError = async (output, context) => {
995
983
  throw await de_ValidationExceptionRes(parsedOutput, context);
996
984
  default:
997
985
  const parsedBody = parsedOutput.body;
998
- throwDefaultError({
986
+ return throwDefaultError({
999
987
  output,
1000
988
  parsedBody,
1001
- exceptionCtor: __BaseException,
1002
989
  errorCode,
1003
990
  });
1004
991
  }
@@ -1009,12 +996,12 @@ export const de_DeleteBatchPredictionJobCommand = async (output, context) => {
1009
996
  }
1010
997
  const data = await parseBody(output.body, context);
1011
998
  let contents = {};
1012
- contents = de_DeleteBatchPredictionJobResult(data, context);
999
+ contents = _json(data);
1013
1000
  const response = {
1014
1001
  $metadata: deserializeMetadata(output),
1015
1002
  ...contents,
1016
1003
  };
1017
- return Promise.resolve(response);
1004
+ return response;
1018
1005
  };
1019
1006
  const de_DeleteBatchPredictionJobCommandError = async (output, context) => {
1020
1007
  const parsedOutput = {
@@ -1037,10 +1024,9 @@ const de_DeleteBatchPredictionJobCommandError = async (output, context) => {
1037
1024
  throw await de_ValidationExceptionRes(parsedOutput, context);
1038
1025
  default:
1039
1026
  const parsedBody = parsedOutput.body;
1040
- throwDefaultError({
1027
+ return throwDefaultError({
1041
1028
  output,
1042
1029
  parsedBody,
1043
- exceptionCtor: __BaseException,
1044
1030
  errorCode,
1045
1031
  });
1046
1032
  }
@@ -1051,12 +1037,12 @@ export const de_DeleteDetectorCommand = async (output, context) => {
1051
1037
  }
1052
1038
  const data = await parseBody(output.body, context);
1053
1039
  let contents = {};
1054
- contents = de_DeleteDetectorResult(data, context);
1040
+ contents = _json(data);
1055
1041
  const response = {
1056
1042
  $metadata: deserializeMetadata(output),
1057
1043
  ...contents,
1058
1044
  };
1059
- return Promise.resolve(response);
1045
+ return response;
1060
1046
  };
1061
1047
  const de_DeleteDetectorCommandError = async (output, context) => {
1062
1048
  const parsedOutput = {
@@ -1082,10 +1068,9 @@ const de_DeleteDetectorCommandError = async (output, context) => {
1082
1068
  throw await de_ValidationExceptionRes(parsedOutput, context);
1083
1069
  default:
1084
1070
  const parsedBody = parsedOutput.body;
1085
- throwDefaultError({
1071
+ return throwDefaultError({
1086
1072
  output,
1087
1073
  parsedBody,
1088
- exceptionCtor: __BaseException,
1089
1074
  errorCode,
1090
1075
  });
1091
1076
  }
@@ -1096,12 +1081,12 @@ export const de_DeleteDetectorVersionCommand = async (output, context) => {
1096
1081
  }
1097
1082
  const data = await parseBody(output.body, context);
1098
1083
  let contents = {};
1099
- contents = de_DeleteDetectorVersionResult(data, context);
1084
+ contents = _json(data);
1100
1085
  const response = {
1101
1086
  $metadata: deserializeMetadata(output),
1102
1087
  ...contents,
1103
1088
  };
1104
- return Promise.resolve(response);
1089
+ return response;
1105
1090
  };
1106
1091
  const de_DeleteDetectorVersionCommandError = async (output, context) => {
1107
1092
  const parsedOutput = {
@@ -1130,10 +1115,9 @@ const de_DeleteDetectorVersionCommandError = async (output, context) => {
1130
1115
  throw await de_ValidationExceptionRes(parsedOutput, context);
1131
1116
  default:
1132
1117
  const parsedBody = parsedOutput.body;
1133
- throwDefaultError({
1118
+ return throwDefaultError({
1134
1119
  output,
1135
1120
  parsedBody,
1136
- exceptionCtor: __BaseException,
1137
1121
  errorCode,
1138
1122
  });
1139
1123
  }
@@ -1144,12 +1128,12 @@ export const de_DeleteEntityTypeCommand = async (output, context) => {
1144
1128
  }
1145
1129
  const data = await parseBody(output.body, context);
1146
1130
  let contents = {};
1147
- contents = de_DeleteEntityTypeResult(data, context);
1131
+ contents = _json(data);
1148
1132
  const response = {
1149
1133
  $metadata: deserializeMetadata(output),
1150
1134
  ...contents,
1151
1135
  };
1152
- return Promise.resolve(response);
1136
+ return response;
1153
1137
  };
1154
1138
  const de_DeleteEntityTypeCommandError = async (output, context) => {
1155
1139
  const parsedOutput = {
@@ -1175,10 +1159,9 @@ const de_DeleteEntityTypeCommandError = async (output, context) => {
1175
1159
  throw await de_ValidationExceptionRes(parsedOutput, context);
1176
1160
  default:
1177
1161
  const parsedBody = parsedOutput.body;
1178
- throwDefaultError({
1162
+ return throwDefaultError({
1179
1163
  output,
1180
1164
  parsedBody,
1181
- exceptionCtor: __BaseException,
1182
1165
  errorCode,
1183
1166
  });
1184
1167
  }
@@ -1189,12 +1172,12 @@ export const de_DeleteEventCommand = async (output, context) => {
1189
1172
  }
1190
1173
  const data = await parseBody(output.body, context);
1191
1174
  let contents = {};
1192
- contents = de_DeleteEventResult(data, context);
1175
+ contents = _json(data);
1193
1176
  const response = {
1194
1177
  $metadata: deserializeMetadata(output),
1195
1178
  ...contents,
1196
1179
  };
1197
- return Promise.resolve(response);
1180
+ return response;
1198
1181
  };
1199
1182
  const de_DeleteEventCommandError = async (output, context) => {
1200
1183
  const parsedOutput = {
@@ -1217,10 +1200,9 @@ const de_DeleteEventCommandError = async (output, context) => {
1217
1200
  throw await de_ValidationExceptionRes(parsedOutput, context);
1218
1201
  default:
1219
1202
  const parsedBody = parsedOutput.body;
1220
- throwDefaultError({
1203
+ return throwDefaultError({
1221
1204
  output,
1222
1205
  parsedBody,
1223
- exceptionCtor: __BaseException,
1224
1206
  errorCode,
1225
1207
  });
1226
1208
  }
@@ -1231,12 +1213,12 @@ export const de_DeleteEventsByEventTypeCommand = async (output, context) => {
1231
1213
  }
1232
1214
  const data = await parseBody(output.body, context);
1233
1215
  let contents = {};
1234
- contents = de_DeleteEventsByEventTypeResult(data, context);
1216
+ contents = _json(data);
1235
1217
  const response = {
1236
1218
  $metadata: deserializeMetadata(output),
1237
1219
  ...contents,
1238
1220
  };
1239
- return Promise.resolve(response);
1221
+ return response;
1240
1222
  };
1241
1223
  const de_DeleteEventsByEventTypeCommandError = async (output, context) => {
1242
1224
  const parsedOutput = {
@@ -1265,10 +1247,9 @@ const de_DeleteEventsByEventTypeCommandError = async (output, context) => {
1265
1247
  throw await de_ValidationExceptionRes(parsedOutput, context);
1266
1248
  default:
1267
1249
  const parsedBody = parsedOutput.body;
1268
- throwDefaultError({
1250
+ return throwDefaultError({
1269
1251
  output,
1270
1252
  parsedBody,
1271
- exceptionCtor: __BaseException,
1272
1253
  errorCode,
1273
1254
  });
1274
1255
  }
@@ -1279,12 +1260,12 @@ export const de_DeleteEventTypeCommand = async (output, context) => {
1279
1260
  }
1280
1261
  const data = await parseBody(output.body, context);
1281
1262
  let contents = {};
1282
- contents = de_DeleteEventTypeResult(data, context);
1263
+ contents = _json(data);
1283
1264
  const response = {
1284
1265
  $metadata: deserializeMetadata(output),
1285
1266
  ...contents,
1286
1267
  };
1287
- return Promise.resolve(response);
1268
+ return response;
1288
1269
  };
1289
1270
  const de_DeleteEventTypeCommandError = async (output, context) => {
1290
1271
  const parsedOutput = {
@@ -1310,10 +1291,9 @@ const de_DeleteEventTypeCommandError = async (output, context) => {
1310
1291
  throw await de_ValidationExceptionRes(parsedOutput, context);
1311
1292
  default:
1312
1293
  const parsedBody = parsedOutput.body;
1313
- throwDefaultError({
1294
+ return throwDefaultError({
1314
1295
  output,
1315
1296
  parsedBody,
1316
- exceptionCtor: __BaseException,
1317
1297
  errorCode,
1318
1298
  });
1319
1299
  }
@@ -1324,12 +1304,12 @@ export const de_DeleteExternalModelCommand = async (output, context) => {
1324
1304
  }
1325
1305
  const data = await parseBody(output.body, context);
1326
1306
  let contents = {};
1327
- contents = de_DeleteExternalModelResult(data, context);
1307
+ contents = _json(data);
1328
1308
  const response = {
1329
1309
  $metadata: deserializeMetadata(output),
1330
1310
  ...contents,
1331
1311
  };
1332
- return Promise.resolve(response);
1312
+ return response;
1333
1313
  };
1334
1314
  const de_DeleteExternalModelCommandError = async (output, context) => {
1335
1315
  const parsedOutput = {
@@ -1355,10 +1335,9 @@ const de_DeleteExternalModelCommandError = async (output, context) => {
1355
1335
  throw await de_ValidationExceptionRes(parsedOutput, context);
1356
1336
  default:
1357
1337
  const parsedBody = parsedOutput.body;
1358
- throwDefaultError({
1338
+ return throwDefaultError({
1359
1339
  output,
1360
1340
  parsedBody,
1361
- exceptionCtor: __BaseException,
1362
1341
  errorCode,
1363
1342
  });
1364
1343
  }
@@ -1369,12 +1348,12 @@ export const de_DeleteLabelCommand = async (output, context) => {
1369
1348
  }
1370
1349
  const data = await parseBody(output.body, context);
1371
1350
  let contents = {};
1372
- contents = de_DeleteLabelResult(data, context);
1351
+ contents = _json(data);
1373
1352
  const response = {
1374
1353
  $metadata: deserializeMetadata(output),
1375
1354
  ...contents,
1376
1355
  };
1377
- return Promise.resolve(response);
1356
+ return response;
1378
1357
  };
1379
1358
  const de_DeleteLabelCommandError = async (output, context) => {
1380
1359
  const parsedOutput = {
@@ -1397,10 +1376,9 @@ const de_DeleteLabelCommandError = async (output, context) => {
1397
1376
  throw await de_ValidationExceptionRes(parsedOutput, context);
1398
1377
  default:
1399
1378
  const parsedBody = parsedOutput.body;
1400
- throwDefaultError({
1379
+ return throwDefaultError({
1401
1380
  output,
1402
1381
  parsedBody,
1403
- exceptionCtor: __BaseException,
1404
1382
  errorCode,
1405
1383
  });
1406
1384
  }
@@ -1411,12 +1389,12 @@ export const de_DeleteListCommand = async (output, context) => {
1411
1389
  }
1412
1390
  const data = await parseBody(output.body, context);
1413
1391
  let contents = {};
1414
- contents = de_DeleteListResult(data, context);
1392
+ contents = _json(data);
1415
1393
  const response = {
1416
1394
  $metadata: deserializeMetadata(output),
1417
1395
  ...contents,
1418
1396
  };
1419
- return Promise.resolve(response);
1397
+ return response;
1420
1398
  };
1421
1399
  const de_DeleteListCommandError = async (output, context) => {
1422
1400
  const parsedOutput = {
@@ -1442,10 +1420,9 @@ const de_DeleteListCommandError = async (output, context) => {
1442
1420
  throw await de_ValidationExceptionRes(parsedOutput, context);
1443
1421
  default:
1444
1422
  const parsedBody = parsedOutput.body;
1445
- throwDefaultError({
1423
+ return throwDefaultError({
1446
1424
  output,
1447
1425
  parsedBody,
1448
- exceptionCtor: __BaseException,
1449
1426
  errorCode,
1450
1427
  });
1451
1428
  }
@@ -1456,12 +1433,12 @@ export const de_DeleteModelCommand = async (output, context) => {
1456
1433
  }
1457
1434
  const data = await parseBody(output.body, context);
1458
1435
  let contents = {};
1459
- contents = de_DeleteModelResult(data, context);
1436
+ contents = _json(data);
1460
1437
  const response = {
1461
1438
  $metadata: deserializeMetadata(output),
1462
1439
  ...contents,
1463
1440
  };
1464
- return Promise.resolve(response);
1441
+ return response;
1465
1442
  };
1466
1443
  const de_DeleteModelCommandError = async (output, context) => {
1467
1444
  const parsedOutput = {
@@ -1487,10 +1464,9 @@ const de_DeleteModelCommandError = async (output, context) => {
1487
1464
  throw await de_ValidationExceptionRes(parsedOutput, context);
1488
1465
  default:
1489
1466
  const parsedBody = parsedOutput.body;
1490
- throwDefaultError({
1467
+ return throwDefaultError({
1491
1468
  output,
1492
1469
  parsedBody,
1493
- exceptionCtor: __BaseException,
1494
1470
  errorCode,
1495
1471
  });
1496
1472
  }
@@ -1501,12 +1477,12 @@ export const de_DeleteModelVersionCommand = async (output, context) => {
1501
1477
  }
1502
1478
  const data = await parseBody(output.body, context);
1503
1479
  let contents = {};
1504
- contents = de_DeleteModelVersionResult(data, context);
1480
+ contents = _json(data);
1505
1481
  const response = {
1506
1482
  $metadata: deserializeMetadata(output),
1507
1483
  ...contents,
1508
1484
  };
1509
- return Promise.resolve(response);
1485
+ return response;
1510
1486
  };
1511
1487
  const de_DeleteModelVersionCommandError = async (output, context) => {
1512
1488
  const parsedOutput = {
@@ -1532,10 +1508,9 @@ const de_DeleteModelVersionCommandError = async (output, context) => {
1532
1508
  throw await de_ValidationExceptionRes(parsedOutput, context);
1533
1509
  default:
1534
1510
  const parsedBody = parsedOutput.body;
1535
- throwDefaultError({
1511
+ return throwDefaultError({
1536
1512
  output,
1537
1513
  parsedBody,
1538
- exceptionCtor: __BaseException,
1539
1514
  errorCode,
1540
1515
  });
1541
1516
  }
@@ -1546,12 +1521,12 @@ export const de_DeleteOutcomeCommand = async (output, context) => {
1546
1521
  }
1547
1522
  const data = await parseBody(output.body, context);
1548
1523
  let contents = {};
1549
- contents = de_DeleteOutcomeResult(data, context);
1524
+ contents = _json(data);
1550
1525
  const response = {
1551
1526
  $metadata: deserializeMetadata(output),
1552
1527
  ...contents,
1553
1528
  };
1554
- return Promise.resolve(response);
1529
+ return response;
1555
1530
  };
1556
1531
  const de_DeleteOutcomeCommandError = async (output, context) => {
1557
1532
  const parsedOutput = {
@@ -1577,10 +1552,9 @@ const de_DeleteOutcomeCommandError = async (output, context) => {
1577
1552
  throw await de_ValidationExceptionRes(parsedOutput, context);
1578
1553
  default:
1579
1554
  const parsedBody = parsedOutput.body;
1580
- throwDefaultError({
1555
+ return throwDefaultError({
1581
1556
  output,
1582
1557
  parsedBody,
1583
- exceptionCtor: __BaseException,
1584
1558
  errorCode,
1585
1559
  });
1586
1560
  }
@@ -1591,12 +1565,12 @@ export const de_DeleteRuleCommand = async (output, context) => {
1591
1565
  }
1592
1566
  const data = await parseBody(output.body, context);
1593
1567
  let contents = {};
1594
- contents = de_DeleteRuleResult(data, context);
1568
+ contents = _json(data);
1595
1569
  const response = {
1596
1570
  $metadata: deserializeMetadata(output),
1597
1571
  ...contents,
1598
1572
  };
1599
- return Promise.resolve(response);
1573
+ return response;
1600
1574
  };
1601
1575
  const de_DeleteRuleCommandError = async (output, context) => {
1602
1576
  const parsedOutput = {
@@ -1622,10 +1596,9 @@ const de_DeleteRuleCommandError = async (output, context) => {
1622
1596
  throw await de_ValidationExceptionRes(parsedOutput, context);
1623
1597
  default:
1624
1598
  const parsedBody = parsedOutput.body;
1625
- throwDefaultError({
1599
+ return throwDefaultError({
1626
1600
  output,
1627
1601
  parsedBody,
1628
- exceptionCtor: __BaseException,
1629
1602
  errorCode,
1630
1603
  });
1631
1604
  }
@@ -1636,12 +1609,12 @@ export const de_DeleteVariableCommand = async (output, context) => {
1636
1609
  }
1637
1610
  const data = await parseBody(output.body, context);
1638
1611
  let contents = {};
1639
- contents = de_DeleteVariableResult(data, context);
1612
+ contents = _json(data);
1640
1613
  const response = {
1641
1614
  $metadata: deserializeMetadata(output),
1642
1615
  ...contents,
1643
1616
  };
1644
- return Promise.resolve(response);
1617
+ return response;
1645
1618
  };
1646
1619
  const de_DeleteVariableCommandError = async (output, context) => {
1647
1620
  const parsedOutput = {
@@ -1667,10 +1640,9 @@ const de_DeleteVariableCommandError = async (output, context) => {
1667
1640
  throw await de_ValidationExceptionRes(parsedOutput, context);
1668
1641
  default:
1669
1642
  const parsedBody = parsedOutput.body;
1670
- throwDefaultError({
1643
+ return throwDefaultError({
1671
1644
  output,
1672
1645
  parsedBody,
1673
- exceptionCtor: __BaseException,
1674
1646
  errorCode,
1675
1647
  });
1676
1648
  }
@@ -1681,12 +1653,12 @@ export const de_DescribeDetectorCommand = async (output, context) => {
1681
1653
  }
1682
1654
  const data = await parseBody(output.body, context);
1683
1655
  let contents = {};
1684
- contents = de_DescribeDetectorResult(data, context);
1656
+ contents = _json(data);
1685
1657
  const response = {
1686
1658
  $metadata: deserializeMetadata(output),
1687
1659
  ...contents,
1688
1660
  };
1689
- return Promise.resolve(response);
1661
+ return response;
1690
1662
  };
1691
1663
  const de_DescribeDetectorCommandError = async (output, context) => {
1692
1664
  const parsedOutput = {
@@ -1712,10 +1684,9 @@ const de_DescribeDetectorCommandError = async (output, context) => {
1712
1684
  throw await de_ValidationExceptionRes(parsedOutput, context);
1713
1685
  default:
1714
1686
  const parsedBody = parsedOutput.body;
1715
- throwDefaultError({
1687
+ return throwDefaultError({
1716
1688
  output,
1717
1689
  parsedBody,
1718
- exceptionCtor: __BaseException,
1719
1690
  errorCode,
1720
1691
  });
1721
1692
  }
@@ -1731,7 +1702,7 @@ export const de_DescribeModelVersionsCommand = async (output, context) => {
1731
1702
  $metadata: deserializeMetadata(output),
1732
1703
  ...contents,
1733
1704
  };
1734
- return Promise.resolve(response);
1705
+ return response;
1735
1706
  };
1736
1707
  const de_DescribeModelVersionsCommandError = async (output, context) => {
1737
1708
  const parsedOutput = {
@@ -1757,10 +1728,9 @@ const de_DescribeModelVersionsCommandError = async (output, context) => {
1757
1728
  throw await de_ValidationExceptionRes(parsedOutput, context);
1758
1729
  default:
1759
1730
  const parsedBody = parsedOutput.body;
1760
- throwDefaultError({
1731
+ return throwDefaultError({
1761
1732
  output,
1762
1733
  parsedBody,
1763
- exceptionCtor: __BaseException,
1764
1734
  errorCode,
1765
1735
  });
1766
1736
  }
@@ -1771,12 +1741,12 @@ export const de_GetBatchImportJobsCommand = async (output, context) => {
1771
1741
  }
1772
1742
  const data = await parseBody(output.body, context);
1773
1743
  let contents = {};
1774
- contents = de_GetBatchImportJobsResult(data, context);
1744
+ contents = _json(data);
1775
1745
  const response = {
1776
1746
  $metadata: deserializeMetadata(output),
1777
1747
  ...contents,
1778
1748
  };
1779
- return Promise.resolve(response);
1749
+ return response;
1780
1750
  };
1781
1751
  const de_GetBatchImportJobsCommandError = async (output, context) => {
1782
1752
  const parsedOutput = {
@@ -1802,10 +1772,9 @@ const de_GetBatchImportJobsCommandError = async (output, context) => {
1802
1772
  throw await de_ValidationExceptionRes(parsedOutput, context);
1803
1773
  default:
1804
1774
  const parsedBody = parsedOutput.body;
1805
- throwDefaultError({
1775
+ return throwDefaultError({
1806
1776
  output,
1807
1777
  parsedBody,
1808
- exceptionCtor: __BaseException,
1809
1778
  errorCode,
1810
1779
  });
1811
1780
  }
@@ -1816,12 +1785,12 @@ export const de_GetBatchPredictionJobsCommand = async (output, context) => {
1816
1785
  }
1817
1786
  const data = await parseBody(output.body, context);
1818
1787
  let contents = {};
1819
- contents = de_GetBatchPredictionJobsResult(data, context);
1788
+ contents = _json(data);
1820
1789
  const response = {
1821
1790
  $metadata: deserializeMetadata(output),
1822
1791
  ...contents,
1823
1792
  };
1824
- return Promise.resolve(response);
1793
+ return response;
1825
1794
  };
1826
1795
  const de_GetBatchPredictionJobsCommandError = async (output, context) => {
1827
1796
  const parsedOutput = {
@@ -1847,10 +1816,9 @@ const de_GetBatchPredictionJobsCommandError = async (output, context) => {
1847
1816
  throw await de_ValidationExceptionRes(parsedOutput, context);
1848
1817
  default:
1849
1818
  const parsedBody = parsedOutput.body;
1850
- throwDefaultError({
1819
+ return throwDefaultError({
1851
1820
  output,
1852
1821
  parsedBody,
1853
- exceptionCtor: __BaseException,
1854
1822
  errorCode,
1855
1823
  });
1856
1824
  }
@@ -1861,12 +1829,12 @@ export const de_GetDeleteEventsByEventTypeStatusCommand = async (output, context
1861
1829
  }
1862
1830
  const data = await parseBody(output.body, context);
1863
1831
  let contents = {};
1864
- contents = de_GetDeleteEventsByEventTypeStatusResult(data, context);
1832
+ contents = _json(data);
1865
1833
  const response = {
1866
1834
  $metadata: deserializeMetadata(output),
1867
1835
  ...contents,
1868
1836
  };
1869
- return Promise.resolve(response);
1837
+ return response;
1870
1838
  };
1871
1839
  const de_GetDeleteEventsByEventTypeStatusCommandError = async (output, context) => {
1872
1840
  const parsedOutput = {
@@ -1892,10 +1860,9 @@ const de_GetDeleteEventsByEventTypeStatusCommandError = async (output, context)
1892
1860
  throw await de_ValidationExceptionRes(parsedOutput, context);
1893
1861
  default:
1894
1862
  const parsedBody = parsedOutput.body;
1895
- throwDefaultError({
1863
+ return throwDefaultError({
1896
1864
  output,
1897
1865
  parsedBody,
1898
- exceptionCtor: __BaseException,
1899
1866
  errorCode,
1900
1867
  });
1901
1868
  }
@@ -1906,12 +1873,12 @@ export const de_GetDetectorsCommand = async (output, context) => {
1906
1873
  }
1907
1874
  const data = await parseBody(output.body, context);
1908
1875
  let contents = {};
1909
- contents = de_GetDetectorsResult(data, context);
1876
+ contents = _json(data);
1910
1877
  const response = {
1911
1878
  $metadata: deserializeMetadata(output),
1912
1879
  ...contents,
1913
1880
  };
1914
- return Promise.resolve(response);
1881
+ return response;
1915
1882
  };
1916
1883
  const de_GetDetectorsCommandError = async (output, context) => {
1917
1884
  const parsedOutput = {
@@ -1937,10 +1904,9 @@ const de_GetDetectorsCommandError = async (output, context) => {
1937
1904
  throw await de_ValidationExceptionRes(parsedOutput, context);
1938
1905
  default:
1939
1906
  const parsedBody = parsedOutput.body;
1940
- throwDefaultError({
1907
+ return throwDefaultError({
1941
1908
  output,
1942
1909
  parsedBody,
1943
- exceptionCtor: __BaseException,
1944
1910
  errorCode,
1945
1911
  });
1946
1912
  }
@@ -1951,12 +1917,12 @@ export const de_GetDetectorVersionCommand = async (output, context) => {
1951
1917
  }
1952
1918
  const data = await parseBody(output.body, context);
1953
1919
  let contents = {};
1954
- contents = de_GetDetectorVersionResult(data, context);
1920
+ contents = _json(data);
1955
1921
  const response = {
1956
1922
  $metadata: deserializeMetadata(output),
1957
1923
  ...contents,
1958
1924
  };
1959
- return Promise.resolve(response);
1925
+ return response;
1960
1926
  };
1961
1927
  const de_GetDetectorVersionCommandError = async (output, context) => {
1962
1928
  const parsedOutput = {
@@ -1982,10 +1948,9 @@ const de_GetDetectorVersionCommandError = async (output, context) => {
1982
1948
  throw await de_ValidationExceptionRes(parsedOutput, context);
1983
1949
  default:
1984
1950
  const parsedBody = parsedOutput.body;
1985
- throwDefaultError({
1951
+ return throwDefaultError({
1986
1952
  output,
1987
1953
  parsedBody,
1988
- exceptionCtor: __BaseException,
1989
1954
  errorCode,
1990
1955
  });
1991
1956
  }
@@ -1996,12 +1961,12 @@ export const de_GetEntityTypesCommand = async (output, context) => {
1996
1961
  }
1997
1962
  const data = await parseBody(output.body, context);
1998
1963
  let contents = {};
1999
- contents = de_GetEntityTypesResult(data, context);
1964
+ contents = _json(data);
2000
1965
  const response = {
2001
1966
  $metadata: deserializeMetadata(output),
2002
1967
  ...contents,
2003
1968
  };
2004
- return Promise.resolve(response);
1969
+ return response;
2005
1970
  };
2006
1971
  const de_GetEntityTypesCommandError = async (output, context) => {
2007
1972
  const parsedOutput = {
@@ -2027,10 +1992,9 @@ const de_GetEntityTypesCommandError = async (output, context) => {
2027
1992
  throw await de_ValidationExceptionRes(parsedOutput, context);
2028
1993
  default:
2029
1994
  const parsedBody = parsedOutput.body;
2030
- throwDefaultError({
1995
+ return throwDefaultError({
2031
1996
  output,
2032
1997
  parsedBody,
2033
- exceptionCtor: __BaseException,
2034
1998
  errorCode,
2035
1999
  });
2036
2000
  }
@@ -2041,12 +2005,12 @@ export const de_GetEventCommand = async (output, context) => {
2041
2005
  }
2042
2006
  const data = await parseBody(output.body, context);
2043
2007
  let contents = {};
2044
- contents = de_GetEventResult(data, context);
2008
+ contents = _json(data);
2045
2009
  const response = {
2046
2010
  $metadata: deserializeMetadata(output),
2047
2011
  ...contents,
2048
2012
  };
2049
- return Promise.resolve(response);
2013
+ return response;
2050
2014
  };
2051
2015
  const de_GetEventCommandError = async (output, context) => {
2052
2016
  const parsedOutput = {
@@ -2072,10 +2036,9 @@ const de_GetEventCommandError = async (output, context) => {
2072
2036
  throw await de_ValidationExceptionRes(parsedOutput, context);
2073
2037
  default:
2074
2038
  const parsedBody = parsedOutput.body;
2075
- throwDefaultError({
2039
+ return throwDefaultError({
2076
2040
  output,
2077
2041
  parsedBody,
2078
- exceptionCtor: __BaseException,
2079
2042
  errorCode,
2080
2043
  });
2081
2044
  }
@@ -2091,7 +2054,7 @@ export const de_GetEventPredictionCommand = async (output, context) => {
2091
2054
  $metadata: deserializeMetadata(output),
2092
2055
  ...contents,
2093
2056
  };
2094
- return Promise.resolve(response);
2057
+ return response;
2095
2058
  };
2096
2059
  const de_GetEventPredictionCommandError = async (output, context) => {
2097
2060
  const parsedOutput = {
@@ -2123,10 +2086,9 @@ const de_GetEventPredictionCommandError = async (output, context) => {
2123
2086
  throw await de_ValidationExceptionRes(parsedOutput, context);
2124
2087
  default:
2125
2088
  const parsedBody = parsedOutput.body;
2126
- throwDefaultError({
2089
+ return throwDefaultError({
2127
2090
  output,
2128
2091
  parsedBody,
2129
- exceptionCtor: __BaseException,
2130
2092
  errorCode,
2131
2093
  });
2132
2094
  }
@@ -2142,7 +2104,7 @@ export const de_GetEventPredictionMetadataCommand = async (output, context) => {
2142
2104
  $metadata: deserializeMetadata(output),
2143
2105
  ...contents,
2144
2106
  };
2145
- return Promise.resolve(response);
2107
+ return response;
2146
2108
  };
2147
2109
  const de_GetEventPredictionMetadataCommandError = async (output, context) => {
2148
2110
  const parsedOutput = {
@@ -2168,10 +2130,9 @@ const de_GetEventPredictionMetadataCommandError = async (output, context) => {
2168
2130
  throw await de_ValidationExceptionRes(parsedOutput, context);
2169
2131
  default:
2170
2132
  const parsedBody = parsedOutput.body;
2171
- throwDefaultError({
2133
+ return throwDefaultError({
2172
2134
  output,
2173
2135
  parsedBody,
2174
- exceptionCtor: __BaseException,
2175
2136
  errorCode,
2176
2137
  });
2177
2138
  }
@@ -2182,12 +2143,12 @@ export const de_GetEventTypesCommand = async (output, context) => {
2182
2143
  }
2183
2144
  const data = await parseBody(output.body, context);
2184
2145
  let contents = {};
2185
- contents = de_GetEventTypesResult(data, context);
2146
+ contents = _json(data);
2186
2147
  const response = {
2187
2148
  $metadata: deserializeMetadata(output),
2188
2149
  ...contents,
2189
2150
  };
2190
- return Promise.resolve(response);
2151
+ return response;
2191
2152
  };
2192
2153
  const de_GetEventTypesCommandError = async (output, context) => {
2193
2154
  const parsedOutput = {
@@ -2213,10 +2174,9 @@ const de_GetEventTypesCommandError = async (output, context) => {
2213
2174
  throw await de_ValidationExceptionRes(parsedOutput, context);
2214
2175
  default:
2215
2176
  const parsedBody = parsedOutput.body;
2216
- throwDefaultError({
2177
+ return throwDefaultError({
2217
2178
  output,
2218
2179
  parsedBody,
2219
- exceptionCtor: __BaseException,
2220
2180
  errorCode,
2221
2181
  });
2222
2182
  }
@@ -2227,12 +2187,12 @@ export const de_GetExternalModelsCommand = async (output, context) => {
2227
2187
  }
2228
2188
  const data = await parseBody(output.body, context);
2229
2189
  let contents = {};
2230
- contents = de_GetExternalModelsResult(data, context);
2190
+ contents = _json(data);
2231
2191
  const response = {
2232
2192
  $metadata: deserializeMetadata(output),
2233
2193
  ...contents,
2234
2194
  };
2235
- return Promise.resolve(response);
2195
+ return response;
2236
2196
  };
2237
2197
  const de_GetExternalModelsCommandError = async (output, context) => {
2238
2198
  const parsedOutput = {
@@ -2258,10 +2218,9 @@ const de_GetExternalModelsCommandError = async (output, context) => {
2258
2218
  throw await de_ValidationExceptionRes(parsedOutput, context);
2259
2219
  default:
2260
2220
  const parsedBody = parsedOutput.body;
2261
- throwDefaultError({
2221
+ return throwDefaultError({
2262
2222
  output,
2263
2223
  parsedBody,
2264
- exceptionCtor: __BaseException,
2265
2224
  errorCode,
2266
2225
  });
2267
2226
  }
@@ -2272,12 +2231,12 @@ export const de_GetKMSEncryptionKeyCommand = async (output, context) => {
2272
2231
  }
2273
2232
  const data = await parseBody(output.body, context);
2274
2233
  let contents = {};
2275
- contents = de_GetKMSEncryptionKeyResult(data, context);
2234
+ contents = _json(data);
2276
2235
  const response = {
2277
2236
  $metadata: deserializeMetadata(output),
2278
2237
  ...contents,
2279
2238
  };
2280
- return Promise.resolve(response);
2239
+ return response;
2281
2240
  };
2282
2241
  const de_GetKMSEncryptionKeyCommandError = async (output, context) => {
2283
2242
  const parsedOutput = {
@@ -2300,10 +2259,9 @@ const de_GetKMSEncryptionKeyCommandError = async (output, context) => {
2300
2259
  throw await de_ThrottlingExceptionRes(parsedOutput, context);
2301
2260
  default:
2302
2261
  const parsedBody = parsedOutput.body;
2303
- throwDefaultError({
2262
+ return throwDefaultError({
2304
2263
  output,
2305
2264
  parsedBody,
2306
- exceptionCtor: __BaseException,
2307
2265
  errorCode,
2308
2266
  });
2309
2267
  }
@@ -2314,12 +2272,12 @@ export const de_GetLabelsCommand = async (output, context) => {
2314
2272
  }
2315
2273
  const data = await parseBody(output.body, context);
2316
2274
  let contents = {};
2317
- contents = de_GetLabelsResult(data, context);
2275
+ contents = _json(data);
2318
2276
  const response = {
2319
2277
  $metadata: deserializeMetadata(output),
2320
2278
  ...contents,
2321
2279
  };
2322
- return Promise.resolve(response);
2280
+ return response;
2323
2281
  };
2324
2282
  const de_GetLabelsCommandError = async (output, context) => {
2325
2283
  const parsedOutput = {
@@ -2345,10 +2303,9 @@ const de_GetLabelsCommandError = async (output, context) => {
2345
2303
  throw await de_ValidationExceptionRes(parsedOutput, context);
2346
2304
  default:
2347
2305
  const parsedBody = parsedOutput.body;
2348
- throwDefaultError({
2306
+ return throwDefaultError({
2349
2307
  output,
2350
2308
  parsedBody,
2351
- exceptionCtor: __BaseException,
2352
2309
  errorCode,
2353
2310
  });
2354
2311
  }
@@ -2359,12 +2316,12 @@ export const de_GetListElementsCommand = async (output, context) => {
2359
2316
  }
2360
2317
  const data = await parseBody(output.body, context);
2361
2318
  let contents = {};
2362
- contents = de_GetListElementsResult(data, context);
2319
+ contents = _json(data);
2363
2320
  const response = {
2364
2321
  $metadata: deserializeMetadata(output),
2365
2322
  ...contents,
2366
2323
  };
2367
- return Promise.resolve(response);
2324
+ return response;
2368
2325
  };
2369
2326
  const de_GetListElementsCommandError = async (output, context) => {
2370
2327
  const parsedOutput = {
@@ -2390,10 +2347,9 @@ const de_GetListElementsCommandError = async (output, context) => {
2390
2347
  throw await de_ValidationExceptionRes(parsedOutput, context);
2391
2348
  default:
2392
2349
  const parsedBody = parsedOutput.body;
2393
- throwDefaultError({
2350
+ return throwDefaultError({
2394
2351
  output,
2395
2352
  parsedBody,
2396
- exceptionCtor: __BaseException,
2397
2353
  errorCode,
2398
2354
  });
2399
2355
  }
@@ -2404,12 +2360,12 @@ export const de_GetListsMetadataCommand = async (output, context) => {
2404
2360
  }
2405
2361
  const data = await parseBody(output.body, context);
2406
2362
  let contents = {};
2407
- contents = de_GetListsMetadataResult(data, context);
2363
+ contents = _json(data);
2408
2364
  const response = {
2409
2365
  $metadata: deserializeMetadata(output),
2410
2366
  ...contents,
2411
2367
  };
2412
- return Promise.resolve(response);
2368
+ return response;
2413
2369
  };
2414
2370
  const de_GetListsMetadataCommandError = async (output, context) => {
2415
2371
  const parsedOutput = {
@@ -2435,10 +2391,9 @@ const de_GetListsMetadataCommandError = async (output, context) => {
2435
2391
  throw await de_ValidationExceptionRes(parsedOutput, context);
2436
2392
  default:
2437
2393
  const parsedBody = parsedOutput.body;
2438
- throwDefaultError({
2394
+ return throwDefaultError({
2439
2395
  output,
2440
2396
  parsedBody,
2441
- exceptionCtor: __BaseException,
2442
2397
  errorCode,
2443
2398
  });
2444
2399
  }
@@ -2449,12 +2404,12 @@ export const de_GetModelsCommand = async (output, context) => {
2449
2404
  }
2450
2405
  const data = await parseBody(output.body, context);
2451
2406
  let contents = {};
2452
- contents = de_GetModelsResult(data, context);
2407
+ contents = _json(data);
2453
2408
  const response = {
2454
2409
  $metadata: deserializeMetadata(output),
2455
2410
  ...contents,
2456
2411
  };
2457
- return Promise.resolve(response);
2412
+ return response;
2458
2413
  };
2459
2414
  const de_GetModelsCommandError = async (output, context) => {
2460
2415
  const parsedOutput = {
@@ -2480,10 +2435,9 @@ const de_GetModelsCommandError = async (output, context) => {
2480
2435
  throw await de_ValidationExceptionRes(parsedOutput, context);
2481
2436
  default:
2482
2437
  const parsedBody = parsedOutput.body;
2483
- throwDefaultError({
2438
+ return throwDefaultError({
2484
2439
  output,
2485
2440
  parsedBody,
2486
- exceptionCtor: __BaseException,
2487
2441
  errorCode,
2488
2442
  });
2489
2443
  }
@@ -2494,12 +2448,12 @@ export const de_GetModelVersionCommand = async (output, context) => {
2494
2448
  }
2495
2449
  const data = await parseBody(output.body, context);
2496
2450
  let contents = {};
2497
- contents = de_GetModelVersionResult(data, context);
2451
+ contents = _json(data);
2498
2452
  const response = {
2499
2453
  $metadata: deserializeMetadata(output),
2500
2454
  ...contents,
2501
2455
  };
2502
- return Promise.resolve(response);
2456
+ return response;
2503
2457
  };
2504
2458
  const de_GetModelVersionCommandError = async (output, context) => {
2505
2459
  const parsedOutput = {
@@ -2525,10 +2479,9 @@ const de_GetModelVersionCommandError = async (output, context) => {
2525
2479
  throw await de_ValidationExceptionRes(parsedOutput, context);
2526
2480
  default:
2527
2481
  const parsedBody = parsedOutput.body;
2528
- throwDefaultError({
2482
+ return throwDefaultError({
2529
2483
  output,
2530
2484
  parsedBody,
2531
- exceptionCtor: __BaseException,
2532
2485
  errorCode,
2533
2486
  });
2534
2487
  }
@@ -2539,12 +2492,12 @@ export const de_GetOutcomesCommand = async (output, context) => {
2539
2492
  }
2540
2493
  const data = await parseBody(output.body, context);
2541
2494
  let contents = {};
2542
- contents = de_GetOutcomesResult(data, context);
2495
+ contents = _json(data);
2543
2496
  const response = {
2544
2497
  $metadata: deserializeMetadata(output),
2545
2498
  ...contents,
2546
2499
  };
2547
- return Promise.resolve(response);
2500
+ return response;
2548
2501
  };
2549
2502
  const de_GetOutcomesCommandError = async (output, context) => {
2550
2503
  const parsedOutput = {
@@ -2570,10 +2523,9 @@ const de_GetOutcomesCommandError = async (output, context) => {
2570
2523
  throw await de_ValidationExceptionRes(parsedOutput, context);
2571
2524
  default:
2572
2525
  const parsedBody = parsedOutput.body;
2573
- throwDefaultError({
2526
+ return throwDefaultError({
2574
2527
  output,
2575
2528
  parsedBody,
2576
- exceptionCtor: __BaseException,
2577
2529
  errorCode,
2578
2530
  });
2579
2531
  }
@@ -2584,12 +2536,12 @@ export const de_GetRulesCommand = async (output, context) => {
2584
2536
  }
2585
2537
  const data = await parseBody(output.body, context);
2586
2538
  let contents = {};
2587
- contents = de_GetRulesResult(data, context);
2539
+ contents = _json(data);
2588
2540
  const response = {
2589
2541
  $metadata: deserializeMetadata(output),
2590
2542
  ...contents,
2591
2543
  };
2592
- return Promise.resolve(response);
2544
+ return response;
2593
2545
  };
2594
2546
  const de_GetRulesCommandError = async (output, context) => {
2595
2547
  const parsedOutput = {
@@ -2615,10 +2567,9 @@ const de_GetRulesCommandError = async (output, context) => {
2615
2567
  throw await de_ValidationExceptionRes(parsedOutput, context);
2616
2568
  default:
2617
2569
  const parsedBody = parsedOutput.body;
2618
- throwDefaultError({
2570
+ return throwDefaultError({
2619
2571
  output,
2620
2572
  parsedBody,
2621
- exceptionCtor: __BaseException,
2622
2573
  errorCode,
2623
2574
  });
2624
2575
  }
@@ -2629,12 +2580,12 @@ export const de_GetVariablesCommand = async (output, context) => {
2629
2580
  }
2630
2581
  const data = await parseBody(output.body, context);
2631
2582
  let contents = {};
2632
- contents = de_GetVariablesResult(data, context);
2583
+ contents = _json(data);
2633
2584
  const response = {
2634
2585
  $metadata: deserializeMetadata(output),
2635
2586
  ...contents,
2636
2587
  };
2637
- return Promise.resolve(response);
2588
+ return response;
2638
2589
  };
2639
2590
  const de_GetVariablesCommandError = async (output, context) => {
2640
2591
  const parsedOutput = {
@@ -2660,10 +2611,9 @@ const de_GetVariablesCommandError = async (output, context) => {
2660
2611
  throw await de_ValidationExceptionRes(parsedOutput, context);
2661
2612
  default:
2662
2613
  const parsedBody = parsedOutput.body;
2663
- throwDefaultError({
2614
+ return throwDefaultError({
2664
2615
  output,
2665
2616
  parsedBody,
2666
- exceptionCtor: __BaseException,
2667
2617
  errorCode,
2668
2618
  });
2669
2619
  }
@@ -2674,12 +2624,12 @@ export const de_ListEventPredictionsCommand = async (output, context) => {
2674
2624
  }
2675
2625
  const data = await parseBody(output.body, context);
2676
2626
  let contents = {};
2677
- contents = de_ListEventPredictionsResult(data, context);
2627
+ contents = _json(data);
2678
2628
  const response = {
2679
2629
  $metadata: deserializeMetadata(output),
2680
2630
  ...contents,
2681
2631
  };
2682
- return Promise.resolve(response);
2632
+ return response;
2683
2633
  };
2684
2634
  const de_ListEventPredictionsCommandError = async (output, context) => {
2685
2635
  const parsedOutput = {
@@ -2702,10 +2652,9 @@ const de_ListEventPredictionsCommandError = async (output, context) => {
2702
2652
  throw await de_ValidationExceptionRes(parsedOutput, context);
2703
2653
  default:
2704
2654
  const parsedBody = parsedOutput.body;
2705
- throwDefaultError({
2655
+ return throwDefaultError({
2706
2656
  output,
2707
2657
  parsedBody,
2708
- exceptionCtor: __BaseException,
2709
2658
  errorCode,
2710
2659
  });
2711
2660
  }
@@ -2716,12 +2665,12 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
2716
2665
  }
2717
2666
  const data = await parseBody(output.body, context);
2718
2667
  let contents = {};
2719
- contents = de_ListTagsForResourceResult(data, context);
2668
+ contents = _json(data);
2720
2669
  const response = {
2721
2670
  $metadata: deserializeMetadata(output),
2722
2671
  ...contents,
2723
2672
  };
2724
- return Promise.resolve(response);
2673
+ return response;
2725
2674
  };
2726
2675
  const de_ListTagsForResourceCommandError = async (output, context) => {
2727
2676
  const parsedOutput = {
@@ -2744,10 +2693,9 @@ const de_ListTagsForResourceCommandError = async (output, context) => {
2744
2693
  throw await de_ValidationExceptionRes(parsedOutput, context);
2745
2694
  default:
2746
2695
  const parsedBody = parsedOutput.body;
2747
- throwDefaultError({
2696
+ return throwDefaultError({
2748
2697
  output,
2749
2698
  parsedBody,
2750
- exceptionCtor: __BaseException,
2751
2699
  errorCode,
2752
2700
  });
2753
2701
  }
@@ -2758,12 +2706,12 @@ export const de_PutDetectorCommand = async (output, context) => {
2758
2706
  }
2759
2707
  const data = await parseBody(output.body, context);
2760
2708
  let contents = {};
2761
- contents = de_PutDetectorResult(data, context);
2709
+ contents = _json(data);
2762
2710
  const response = {
2763
2711
  $metadata: deserializeMetadata(output),
2764
2712
  ...contents,
2765
2713
  };
2766
- return Promise.resolve(response);
2714
+ return response;
2767
2715
  };
2768
2716
  const de_PutDetectorCommandError = async (output, context) => {
2769
2717
  const parsedOutput = {
@@ -2789,10 +2737,9 @@ const de_PutDetectorCommandError = async (output, context) => {
2789
2737
  throw await de_ValidationExceptionRes(parsedOutput, context);
2790
2738
  default:
2791
2739
  const parsedBody = parsedOutput.body;
2792
- throwDefaultError({
2740
+ return throwDefaultError({
2793
2741
  output,
2794
2742
  parsedBody,
2795
- exceptionCtor: __BaseException,
2796
2743
  errorCode,
2797
2744
  });
2798
2745
  }
@@ -2803,12 +2750,12 @@ export const de_PutEntityTypeCommand = async (output, context) => {
2803
2750
  }
2804
2751
  const data = await parseBody(output.body, context);
2805
2752
  let contents = {};
2806
- contents = de_PutEntityTypeResult(data, context);
2753
+ contents = _json(data);
2807
2754
  const response = {
2808
2755
  $metadata: deserializeMetadata(output),
2809
2756
  ...contents,
2810
2757
  };
2811
- return Promise.resolve(response);
2758
+ return response;
2812
2759
  };
2813
2760
  const de_PutEntityTypeCommandError = async (output, context) => {
2814
2761
  const parsedOutput = {
@@ -2834,10 +2781,9 @@ const de_PutEntityTypeCommandError = async (output, context) => {
2834
2781
  throw await de_ValidationExceptionRes(parsedOutput, context);
2835
2782
  default:
2836
2783
  const parsedBody = parsedOutput.body;
2837
- throwDefaultError({
2784
+ return throwDefaultError({
2838
2785
  output,
2839
2786
  parsedBody,
2840
- exceptionCtor: __BaseException,
2841
2787
  errorCode,
2842
2788
  });
2843
2789
  }
@@ -2848,12 +2794,12 @@ export const de_PutEventTypeCommand = async (output, context) => {
2848
2794
  }
2849
2795
  const data = await parseBody(output.body, context);
2850
2796
  let contents = {};
2851
- contents = de_PutEventTypeResult(data, context);
2797
+ contents = _json(data);
2852
2798
  const response = {
2853
2799
  $metadata: deserializeMetadata(output),
2854
2800
  ...contents,
2855
2801
  };
2856
- return Promise.resolve(response);
2802
+ return response;
2857
2803
  };
2858
2804
  const de_PutEventTypeCommandError = async (output, context) => {
2859
2805
  const parsedOutput = {
@@ -2879,10 +2825,9 @@ const de_PutEventTypeCommandError = async (output, context) => {
2879
2825
  throw await de_ValidationExceptionRes(parsedOutput, context);
2880
2826
  default:
2881
2827
  const parsedBody = parsedOutput.body;
2882
- throwDefaultError({
2828
+ return throwDefaultError({
2883
2829
  output,
2884
2830
  parsedBody,
2885
- exceptionCtor: __BaseException,
2886
2831
  errorCode,
2887
2832
  });
2888
2833
  }
@@ -2893,12 +2838,12 @@ export const de_PutExternalModelCommand = async (output, context) => {
2893
2838
  }
2894
2839
  const data = await parseBody(output.body, context);
2895
2840
  let contents = {};
2896
- contents = de_PutExternalModelResult(data, context);
2841
+ contents = _json(data);
2897
2842
  const response = {
2898
2843
  $metadata: deserializeMetadata(output),
2899
2844
  ...contents,
2900
2845
  };
2901
- return Promise.resolve(response);
2846
+ return response;
2902
2847
  };
2903
2848
  const de_PutExternalModelCommandError = async (output, context) => {
2904
2849
  const parsedOutput = {
@@ -2924,10 +2869,9 @@ const de_PutExternalModelCommandError = async (output, context) => {
2924
2869
  throw await de_ValidationExceptionRes(parsedOutput, context);
2925
2870
  default:
2926
2871
  const parsedBody = parsedOutput.body;
2927
- throwDefaultError({
2872
+ return throwDefaultError({
2928
2873
  output,
2929
2874
  parsedBody,
2930
- exceptionCtor: __BaseException,
2931
2875
  errorCode,
2932
2876
  });
2933
2877
  }
@@ -2938,12 +2882,12 @@ export const de_PutKMSEncryptionKeyCommand = async (output, context) => {
2938
2882
  }
2939
2883
  const data = await parseBody(output.body, context);
2940
2884
  let contents = {};
2941
- contents = de_PutKMSEncryptionKeyResult(data, context);
2885
+ contents = _json(data);
2942
2886
  const response = {
2943
2887
  $metadata: deserializeMetadata(output),
2944
2888
  ...contents,
2945
2889
  };
2946
- return Promise.resolve(response);
2890
+ return response;
2947
2891
  };
2948
2892
  const de_PutKMSEncryptionKeyCommandError = async (output, context) => {
2949
2893
  const parsedOutput = {
@@ -2972,10 +2916,9 @@ const de_PutKMSEncryptionKeyCommandError = async (output, context) => {
2972
2916
  throw await de_ValidationExceptionRes(parsedOutput, context);
2973
2917
  default:
2974
2918
  const parsedBody = parsedOutput.body;
2975
- throwDefaultError({
2919
+ return throwDefaultError({
2976
2920
  output,
2977
2921
  parsedBody,
2978
- exceptionCtor: __BaseException,
2979
2922
  errorCode,
2980
2923
  });
2981
2924
  }
@@ -2986,12 +2929,12 @@ export const de_PutLabelCommand = async (output, context) => {
2986
2929
  }
2987
2930
  const data = await parseBody(output.body, context);
2988
2931
  let contents = {};
2989
- contents = de_PutLabelResult(data, context);
2932
+ contents = _json(data);
2990
2933
  const response = {
2991
2934
  $metadata: deserializeMetadata(output),
2992
2935
  ...contents,
2993
2936
  };
2994
- return Promise.resolve(response);
2937
+ return response;
2995
2938
  };
2996
2939
  const de_PutLabelCommandError = async (output, context) => {
2997
2940
  const parsedOutput = {
@@ -3017,10 +2960,9 @@ const de_PutLabelCommandError = async (output, context) => {
3017
2960
  throw await de_ValidationExceptionRes(parsedOutput, context);
3018
2961
  default:
3019
2962
  const parsedBody = parsedOutput.body;
3020
- throwDefaultError({
2963
+ return throwDefaultError({
3021
2964
  output,
3022
2965
  parsedBody,
3023
- exceptionCtor: __BaseException,
3024
2966
  errorCode,
3025
2967
  });
3026
2968
  }
@@ -3031,12 +2973,12 @@ export const de_PutOutcomeCommand = async (output, context) => {
3031
2973
  }
3032
2974
  const data = await parseBody(output.body, context);
3033
2975
  let contents = {};
3034
- contents = de_PutOutcomeResult(data, context);
2976
+ contents = _json(data);
3035
2977
  const response = {
3036
2978
  $metadata: deserializeMetadata(output),
3037
2979
  ...contents,
3038
2980
  };
3039
- return Promise.resolve(response);
2981
+ return response;
3040
2982
  };
3041
2983
  const de_PutOutcomeCommandError = async (output, context) => {
3042
2984
  const parsedOutput = {
@@ -3062,10 +3004,9 @@ const de_PutOutcomeCommandError = async (output, context) => {
3062
3004
  throw await de_ValidationExceptionRes(parsedOutput, context);
3063
3005
  default:
3064
3006
  const parsedBody = parsedOutput.body;
3065
- throwDefaultError({
3007
+ return throwDefaultError({
3066
3008
  output,
3067
3009
  parsedBody,
3068
- exceptionCtor: __BaseException,
3069
3010
  errorCode,
3070
3011
  });
3071
3012
  }
@@ -3076,12 +3017,12 @@ export const de_SendEventCommand = async (output, context) => {
3076
3017
  }
3077
3018
  const data = await parseBody(output.body, context);
3078
3019
  let contents = {};
3079
- contents = de_SendEventResult(data, context);
3020
+ contents = _json(data);
3080
3021
  const response = {
3081
3022
  $metadata: deserializeMetadata(output),
3082
3023
  ...contents,
3083
3024
  };
3084
- return Promise.resolve(response);
3025
+ return response;
3085
3026
  };
3086
3027
  const de_SendEventCommandError = async (output, context) => {
3087
3028
  const parsedOutput = {
@@ -3110,10 +3051,9 @@ const de_SendEventCommandError = async (output, context) => {
3110
3051
  throw await de_ValidationExceptionRes(parsedOutput, context);
3111
3052
  default:
3112
3053
  const parsedBody = parsedOutput.body;
3113
- throwDefaultError({
3054
+ return throwDefaultError({
3114
3055
  output,
3115
3056
  parsedBody,
3116
- exceptionCtor: __BaseException,
3117
3057
  errorCode,
3118
3058
  });
3119
3059
  }
@@ -3124,12 +3064,12 @@ export const de_TagResourceCommand = async (output, context) => {
3124
3064
  }
3125
3065
  const data = await parseBody(output.body, context);
3126
3066
  let contents = {};
3127
- contents = de_TagResourceResult(data, context);
3067
+ contents = _json(data);
3128
3068
  const response = {
3129
3069
  $metadata: deserializeMetadata(output),
3130
3070
  ...contents,
3131
3071
  };
3132
- return Promise.resolve(response);
3072
+ return response;
3133
3073
  };
3134
3074
  const de_TagResourceCommandError = async (output, context) => {
3135
3075
  const parsedOutput = {
@@ -3152,10 +3092,9 @@ const de_TagResourceCommandError = async (output, context) => {
3152
3092
  throw await de_ValidationExceptionRes(parsedOutput, context);
3153
3093
  default:
3154
3094
  const parsedBody = parsedOutput.body;
3155
- throwDefaultError({
3095
+ return throwDefaultError({
3156
3096
  output,
3157
3097
  parsedBody,
3158
- exceptionCtor: __BaseException,
3159
3098
  errorCode,
3160
3099
  });
3161
3100
  }
@@ -3166,12 +3105,12 @@ export const de_UntagResourceCommand = async (output, context) => {
3166
3105
  }
3167
3106
  const data = await parseBody(output.body, context);
3168
3107
  let contents = {};
3169
- contents = de_UntagResourceResult(data, context);
3108
+ contents = _json(data);
3170
3109
  const response = {
3171
3110
  $metadata: deserializeMetadata(output),
3172
3111
  ...contents,
3173
3112
  };
3174
- return Promise.resolve(response);
3113
+ return response;
3175
3114
  };
3176
3115
  const de_UntagResourceCommandError = async (output, context) => {
3177
3116
  const parsedOutput = {
@@ -3194,10 +3133,9 @@ const de_UntagResourceCommandError = async (output, context) => {
3194
3133
  throw await de_ValidationExceptionRes(parsedOutput, context);
3195
3134
  default:
3196
3135
  const parsedBody = parsedOutput.body;
3197
- throwDefaultError({
3136
+ return throwDefaultError({
3198
3137
  output,
3199
3138
  parsedBody,
3200
- exceptionCtor: __BaseException,
3201
3139
  errorCode,
3202
3140
  });
3203
3141
  }
@@ -3208,12 +3146,12 @@ export const de_UpdateDetectorVersionCommand = async (output, context) => {
3208
3146
  }
3209
3147
  const data = await parseBody(output.body, context);
3210
3148
  let contents = {};
3211
- contents = de_UpdateDetectorVersionResult(data, context);
3149
+ contents = _json(data);
3212
3150
  const response = {
3213
3151
  $metadata: deserializeMetadata(output),
3214
3152
  ...contents,
3215
3153
  };
3216
- return Promise.resolve(response);
3154
+ return response;
3217
3155
  };
3218
3156
  const de_UpdateDetectorVersionCommandError = async (output, context) => {
3219
3157
  const parsedOutput = {
@@ -3242,10 +3180,9 @@ const de_UpdateDetectorVersionCommandError = async (output, context) => {
3242
3180
  throw await de_ValidationExceptionRes(parsedOutput, context);
3243
3181
  default:
3244
3182
  const parsedBody = parsedOutput.body;
3245
- throwDefaultError({
3183
+ return throwDefaultError({
3246
3184
  output,
3247
3185
  parsedBody,
3248
- exceptionCtor: __BaseException,
3249
3186
  errorCode,
3250
3187
  });
3251
3188
  }
@@ -3256,12 +3193,12 @@ export const de_UpdateDetectorVersionMetadataCommand = async (output, context) =
3256
3193
  }
3257
3194
  const data = await parseBody(output.body, context);
3258
3195
  let contents = {};
3259
- contents = de_UpdateDetectorVersionMetadataResult(data, context);
3196
+ contents = _json(data);
3260
3197
  const response = {
3261
3198
  $metadata: deserializeMetadata(output),
3262
3199
  ...contents,
3263
3200
  };
3264
- return Promise.resolve(response);
3201
+ return response;
3265
3202
  };
3266
3203
  const de_UpdateDetectorVersionMetadataCommandError = async (output, context) => {
3267
3204
  const parsedOutput = {
@@ -3287,10 +3224,9 @@ const de_UpdateDetectorVersionMetadataCommandError = async (output, context) =>
3287
3224
  throw await de_ValidationExceptionRes(parsedOutput, context);
3288
3225
  default:
3289
3226
  const parsedBody = parsedOutput.body;
3290
- throwDefaultError({
3227
+ return throwDefaultError({
3291
3228
  output,
3292
3229
  parsedBody,
3293
- exceptionCtor: __BaseException,
3294
3230
  errorCode,
3295
3231
  });
3296
3232
  }
@@ -3301,12 +3237,12 @@ export const de_UpdateDetectorVersionStatusCommand = async (output, context) =>
3301
3237
  }
3302
3238
  const data = await parseBody(output.body, context);
3303
3239
  let contents = {};
3304
- contents = de_UpdateDetectorVersionStatusResult(data, context);
3240
+ contents = _json(data);
3305
3241
  const response = {
3306
3242
  $metadata: deserializeMetadata(output),
3307
3243
  ...contents,
3308
3244
  };
3309
- return Promise.resolve(response);
3245
+ return response;
3310
3246
  };
3311
3247
  const de_UpdateDetectorVersionStatusCommandError = async (output, context) => {
3312
3248
  const parsedOutput = {
@@ -3335,10 +3271,9 @@ const de_UpdateDetectorVersionStatusCommandError = async (output, context) => {
3335
3271
  throw await de_ValidationExceptionRes(parsedOutput, context);
3336
3272
  default:
3337
3273
  const parsedBody = parsedOutput.body;
3338
- throwDefaultError({
3274
+ return throwDefaultError({
3339
3275
  output,
3340
3276
  parsedBody,
3341
- exceptionCtor: __BaseException,
3342
3277
  errorCode,
3343
3278
  });
3344
3279
  }
@@ -3349,12 +3284,12 @@ export const de_UpdateEventLabelCommand = async (output, context) => {
3349
3284
  }
3350
3285
  const data = await parseBody(output.body, context);
3351
3286
  let contents = {};
3352
- contents = de_UpdateEventLabelResult(data, context);
3287
+ contents = _json(data);
3353
3288
  const response = {
3354
3289
  $metadata: deserializeMetadata(output),
3355
3290
  ...contents,
3356
3291
  };
3357
- return Promise.resolve(response);
3292
+ return response;
3358
3293
  };
3359
3294
  const de_UpdateEventLabelCommandError = async (output, context) => {
3360
3295
  const parsedOutput = {
@@ -3383,10 +3318,9 @@ const de_UpdateEventLabelCommandError = async (output, context) => {
3383
3318
  throw await de_ValidationExceptionRes(parsedOutput, context);
3384
3319
  default:
3385
3320
  const parsedBody = parsedOutput.body;
3386
- throwDefaultError({
3321
+ return throwDefaultError({
3387
3322
  output,
3388
3323
  parsedBody,
3389
- exceptionCtor: __BaseException,
3390
3324
  errorCode,
3391
3325
  });
3392
3326
  }
@@ -3397,12 +3331,12 @@ export const de_UpdateListCommand = async (output, context) => {
3397
3331
  }
3398
3332
  const data = await parseBody(output.body, context);
3399
3333
  let contents = {};
3400
- contents = de_UpdateListResult(data, context);
3334
+ contents = _json(data);
3401
3335
  const response = {
3402
3336
  $metadata: deserializeMetadata(output),
3403
3337
  ...contents,
3404
3338
  };
3405
- return Promise.resolve(response);
3339
+ return response;
3406
3340
  };
3407
3341
  const de_UpdateListCommandError = async (output, context) => {
3408
3342
  const parsedOutput = {
@@ -3431,10 +3365,9 @@ const de_UpdateListCommandError = async (output, context) => {
3431
3365
  throw await de_ValidationExceptionRes(parsedOutput, context);
3432
3366
  default:
3433
3367
  const parsedBody = parsedOutput.body;
3434
- throwDefaultError({
3368
+ return throwDefaultError({
3435
3369
  output,
3436
3370
  parsedBody,
3437
- exceptionCtor: __BaseException,
3438
3371
  errorCode,
3439
3372
  });
3440
3373
  }
@@ -3445,12 +3378,12 @@ export const de_UpdateModelCommand = async (output, context) => {
3445
3378
  }
3446
3379
  const data = await parseBody(output.body, context);
3447
3380
  let contents = {};
3448
- contents = de_UpdateModelResult(data, context);
3381
+ contents = _json(data);
3449
3382
  const response = {
3450
3383
  $metadata: deserializeMetadata(output),
3451
3384
  ...contents,
3452
3385
  };
3453
- return Promise.resolve(response);
3386
+ return response;
3454
3387
  };
3455
3388
  const de_UpdateModelCommandError = async (output, context) => {
3456
3389
  const parsedOutput = {
@@ -3479,10 +3412,9 @@ const de_UpdateModelCommandError = async (output, context) => {
3479
3412
  throw await de_ValidationExceptionRes(parsedOutput, context);
3480
3413
  default:
3481
3414
  const parsedBody = parsedOutput.body;
3482
- throwDefaultError({
3415
+ return throwDefaultError({
3483
3416
  output,
3484
3417
  parsedBody,
3485
- exceptionCtor: __BaseException,
3486
3418
  errorCode,
3487
3419
  });
3488
3420
  }
@@ -3493,12 +3425,12 @@ export const de_UpdateModelVersionCommand = async (output, context) => {
3493
3425
  }
3494
3426
  const data = await parseBody(output.body, context);
3495
3427
  let contents = {};
3496
- contents = de_UpdateModelVersionResult(data, context);
3428
+ contents = _json(data);
3497
3429
  const response = {
3498
3430
  $metadata: deserializeMetadata(output),
3499
3431
  ...contents,
3500
3432
  };
3501
- return Promise.resolve(response);
3433
+ return response;
3502
3434
  };
3503
3435
  const de_UpdateModelVersionCommandError = async (output, context) => {
3504
3436
  const parsedOutput = {
@@ -3527,10 +3459,9 @@ const de_UpdateModelVersionCommandError = async (output, context) => {
3527
3459
  throw await de_ValidationExceptionRes(parsedOutput, context);
3528
3460
  default:
3529
3461
  const parsedBody = parsedOutput.body;
3530
- throwDefaultError({
3462
+ return throwDefaultError({
3531
3463
  output,
3532
3464
  parsedBody,
3533
- exceptionCtor: __BaseException,
3534
3465
  errorCode,
3535
3466
  });
3536
3467
  }
@@ -3541,12 +3472,12 @@ export const de_UpdateModelVersionStatusCommand = async (output, context) => {
3541
3472
  }
3542
3473
  const data = await parseBody(output.body, context);
3543
3474
  let contents = {};
3544
- contents = de_UpdateModelVersionStatusResult(data, context);
3475
+ contents = _json(data);
3545
3476
  const response = {
3546
3477
  $metadata: deserializeMetadata(output),
3547
3478
  ...contents,
3548
3479
  };
3549
- return Promise.resolve(response);
3480
+ return response;
3550
3481
  };
3551
3482
  const de_UpdateModelVersionStatusCommandError = async (output, context) => {
3552
3483
  const parsedOutput = {
@@ -3575,10 +3506,9 @@ const de_UpdateModelVersionStatusCommandError = async (output, context) => {
3575
3506
  throw await de_ValidationExceptionRes(parsedOutput, context);
3576
3507
  default:
3577
3508
  const parsedBody = parsedOutput.body;
3578
- throwDefaultError({
3509
+ return throwDefaultError({
3579
3510
  output,
3580
3511
  parsedBody,
3581
- exceptionCtor: __BaseException,
3582
3512
  errorCode,
3583
3513
  });
3584
3514
  }
@@ -3589,12 +3519,12 @@ export const de_UpdateRuleMetadataCommand = async (output, context) => {
3589
3519
  }
3590
3520
  const data = await parseBody(output.body, context);
3591
3521
  let contents = {};
3592
- contents = de_UpdateRuleMetadataResult(data, context);
3522
+ contents = _json(data);
3593
3523
  const response = {
3594
3524
  $metadata: deserializeMetadata(output),
3595
3525
  ...contents,
3596
3526
  };
3597
- return Promise.resolve(response);
3527
+ return response;
3598
3528
  };
3599
3529
  const de_UpdateRuleMetadataCommandError = async (output, context) => {
3600
3530
  const parsedOutput = {
@@ -3623,10 +3553,9 @@ const de_UpdateRuleMetadataCommandError = async (output, context) => {
3623
3553
  throw await de_ValidationExceptionRes(parsedOutput, context);
3624
3554
  default:
3625
3555
  const parsedBody = parsedOutput.body;
3626
- throwDefaultError({
3556
+ return throwDefaultError({
3627
3557
  output,
3628
3558
  parsedBody,
3629
- exceptionCtor: __BaseException,
3630
3559
  errorCode,
3631
3560
  });
3632
3561
  }
@@ -3637,12 +3566,12 @@ export const de_UpdateRuleVersionCommand = async (output, context) => {
3637
3566
  }
3638
3567
  const data = await parseBody(output.body, context);
3639
3568
  let contents = {};
3640
- contents = de_UpdateRuleVersionResult(data, context);
3569
+ contents = _json(data);
3641
3570
  const response = {
3642
3571
  $metadata: deserializeMetadata(output),
3643
3572
  ...contents,
3644
3573
  };
3645
- return Promise.resolve(response);
3574
+ return response;
3646
3575
  };
3647
3576
  const de_UpdateRuleVersionCommandError = async (output, context) => {
3648
3577
  const parsedOutput = {
@@ -3671,10 +3600,9 @@ const de_UpdateRuleVersionCommandError = async (output, context) => {
3671
3600
  throw await de_ValidationExceptionRes(parsedOutput, context);
3672
3601
  default:
3673
3602
  const parsedBody = parsedOutput.body;
3674
- throwDefaultError({
3603
+ return throwDefaultError({
3675
3604
  output,
3676
3605
  parsedBody,
3677
- exceptionCtor: __BaseException,
3678
3606
  errorCode,
3679
3607
  });
3680
3608
  }
@@ -3685,12 +3613,12 @@ export const de_UpdateVariableCommand = async (output, context) => {
3685
3613
  }
3686
3614
  const data = await parseBody(output.body, context);
3687
3615
  let contents = {};
3688
- contents = de_UpdateVariableResult(data, context);
3616
+ contents = _json(data);
3689
3617
  const response = {
3690
3618
  $metadata: deserializeMetadata(output),
3691
3619
  ...contents,
3692
3620
  };
3693
- return Promise.resolve(response);
3621
+ return response;
3694
3622
  };
3695
3623
  const de_UpdateVariableCommandError = async (output, context) => {
3696
3624
  const parsedOutput = {
@@ -3719,17 +3647,16 @@ const de_UpdateVariableCommandError = async (output, context) => {
3719
3647
  throw await de_ValidationExceptionRes(parsedOutput, context);
3720
3648
  default:
3721
3649
  const parsedBody = parsedOutput.body;
3722
- throwDefaultError({
3650
+ return throwDefaultError({
3723
3651
  output,
3724
3652
  parsedBody,
3725
- exceptionCtor: __BaseException,
3726
3653
  errorCode,
3727
3654
  });
3728
3655
  }
3729
3656
  };
3730
3657
  const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
3731
3658
  const body = parsedOutput.body;
3732
- const deserialized = de_AccessDeniedException(body, context);
3659
+ const deserialized = _json(body);
3733
3660
  const exception = new AccessDeniedException({
3734
3661
  $metadata: deserializeMetadata(parsedOutput),
3735
3662
  ...deserialized,
@@ -3738,7 +3665,7 @@ const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
3738
3665
  };
3739
3666
  const de_ConflictExceptionRes = async (parsedOutput, context) => {
3740
3667
  const body = parsedOutput.body;
3741
- const deserialized = de_ConflictException(body, context);
3668
+ const deserialized = _json(body);
3742
3669
  const exception = new ConflictException({
3743
3670
  $metadata: deserializeMetadata(parsedOutput),
3744
3671
  ...deserialized,
@@ -3747,7 +3674,7 @@ const de_ConflictExceptionRes = async (parsedOutput, context) => {
3747
3674
  };
3748
3675
  const de_InternalServerExceptionRes = async (parsedOutput, context) => {
3749
3676
  const body = parsedOutput.body;
3750
- const deserialized = de_InternalServerException(body, context);
3677
+ const deserialized = _json(body);
3751
3678
  const exception = new InternalServerException({
3752
3679
  $metadata: deserializeMetadata(parsedOutput),
3753
3680
  ...deserialized,
@@ -3756,7 +3683,7 @@ const de_InternalServerExceptionRes = async (parsedOutput, context) => {
3756
3683
  };
3757
3684
  const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
3758
3685
  const body = parsedOutput.body;
3759
- const deserialized = de_ResourceNotFoundException(body, context);
3686
+ const deserialized = _json(body);
3760
3687
  const exception = new ResourceNotFoundException({
3761
3688
  $metadata: deserializeMetadata(parsedOutput),
3762
3689
  ...deserialized,
@@ -3765,7 +3692,7 @@ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
3765
3692
  };
3766
3693
  const de_ResourceUnavailableExceptionRes = async (parsedOutput, context) => {
3767
3694
  const body = parsedOutput.body;
3768
- const deserialized = de_ResourceUnavailableException(body, context);
3695
+ const deserialized = _json(body);
3769
3696
  const exception = new ResourceUnavailableException({
3770
3697
  $metadata: deserializeMetadata(parsedOutput),
3771
3698
  ...deserialized,
@@ -3774,7 +3701,7 @@ const de_ResourceUnavailableExceptionRes = async (parsedOutput, context) => {
3774
3701
  };
3775
3702
  const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
3776
3703
  const body = parsedOutput.body;
3777
- const deserialized = de_ThrottlingException(body, context);
3704
+ const deserialized = _json(body);
3778
3705
  const exception = new ThrottlingException({
3779
3706
  $metadata: deserializeMetadata(parsedOutput),
3780
3707
  ...deserialized,
@@ -3783,265 +3710,13 @@ const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
3783
3710
  };
3784
3711
  const de_ValidationExceptionRes = async (parsedOutput, context) => {
3785
3712
  const body = parsedOutput.body;
3786
- const deserialized = de_ValidationException(body, context);
3713
+ const deserialized = _json(body);
3787
3714
  const exception = new ValidationException({
3788
3715
  $metadata: deserializeMetadata(parsedOutput),
3789
3716
  ...deserialized,
3790
3717
  });
3791
3718
  return __decorateServiceException(exception, body);
3792
3719
  };
3793
- const se_BatchCreateVariableRequest = (input, context) => {
3794
- return {
3795
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
3796
- ...(input.variableEntries != null && { variableEntries: se_VariableEntryList(input.variableEntries, context) }),
3797
- };
3798
- };
3799
- const se_BatchGetVariableRequest = (input, context) => {
3800
- return {
3801
- ...(input.names != null && { names: se_NameList(input.names, context) }),
3802
- };
3803
- };
3804
- const se_CancelBatchImportJobRequest = (input, context) => {
3805
- return {
3806
- ...(input.jobId != null && { jobId: input.jobId }),
3807
- };
3808
- };
3809
- const se_CancelBatchPredictionJobRequest = (input, context) => {
3810
- return {
3811
- ...(input.jobId != null && { jobId: input.jobId }),
3812
- };
3813
- };
3814
- const se_CreateBatchImportJobRequest = (input, context) => {
3815
- return {
3816
- ...(input.eventTypeName != null && { eventTypeName: input.eventTypeName }),
3817
- ...(input.iamRoleArn != null && { iamRoleArn: input.iamRoleArn }),
3818
- ...(input.inputPath != null && { inputPath: input.inputPath }),
3819
- ...(input.jobId != null && { jobId: input.jobId }),
3820
- ...(input.outputPath != null && { outputPath: input.outputPath }),
3821
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
3822
- };
3823
- };
3824
- const se_CreateBatchPredictionJobRequest = (input, context) => {
3825
- return {
3826
- ...(input.detectorName != null && { detectorName: input.detectorName }),
3827
- ...(input.detectorVersion != null && { detectorVersion: input.detectorVersion }),
3828
- ...(input.eventTypeName != null && { eventTypeName: input.eventTypeName }),
3829
- ...(input.iamRoleArn != null && { iamRoleArn: input.iamRoleArn }),
3830
- ...(input.inputPath != null && { inputPath: input.inputPath }),
3831
- ...(input.jobId != null && { jobId: input.jobId }),
3832
- ...(input.outputPath != null && { outputPath: input.outputPath }),
3833
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
3834
- };
3835
- };
3836
- const se_CreateDetectorVersionRequest = (input, context) => {
3837
- return {
3838
- ...(input.description != null && { description: input.description }),
3839
- ...(input.detectorId != null && { detectorId: input.detectorId }),
3840
- ...(input.externalModelEndpoints != null && {
3841
- externalModelEndpoints: se_ListOfStrings(input.externalModelEndpoints, context),
3842
- }),
3843
- ...(input.modelVersions != null && { modelVersions: se_ListOfModelVersions(input.modelVersions, context) }),
3844
- ...(input.ruleExecutionMode != null && { ruleExecutionMode: input.ruleExecutionMode }),
3845
- ...(input.rules != null && { rules: se_RuleList(input.rules, context) }),
3846
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
3847
- };
3848
- };
3849
- const se_CreateListRequest = (input, context) => {
3850
- return {
3851
- ...(input.description != null && { description: input.description }),
3852
- ...(input.elements != null && { elements: se_ElementsList(input.elements, context) }),
3853
- ...(input.name != null && { name: input.name }),
3854
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
3855
- ...(input.variableType != null && { variableType: input.variableType }),
3856
- };
3857
- };
3858
- const se_CreateModelRequest = (input, context) => {
3859
- return {
3860
- ...(input.description != null && { description: input.description }),
3861
- ...(input.eventTypeName != null && { eventTypeName: input.eventTypeName }),
3862
- ...(input.modelId != null && { modelId: input.modelId }),
3863
- ...(input.modelType != null && { modelType: input.modelType }),
3864
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
3865
- };
3866
- };
3867
- const se_CreateModelVersionRequest = (input, context) => {
3868
- return {
3869
- ...(input.externalEventsDetail != null && {
3870
- externalEventsDetail: se_ExternalEventsDetail(input.externalEventsDetail, context),
3871
- }),
3872
- ...(input.ingestedEventsDetail != null && {
3873
- ingestedEventsDetail: se_IngestedEventsDetail(input.ingestedEventsDetail, context),
3874
- }),
3875
- ...(input.modelId != null && { modelId: input.modelId }),
3876
- ...(input.modelType != null && { modelType: input.modelType }),
3877
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
3878
- ...(input.trainingDataSchema != null && {
3879
- trainingDataSchema: se_TrainingDataSchema(input.trainingDataSchema, context),
3880
- }),
3881
- ...(input.trainingDataSource != null && { trainingDataSource: input.trainingDataSource }),
3882
- };
3883
- };
3884
- const se_CreateRuleRequest = (input, context) => {
3885
- return {
3886
- ...(input.description != null && { description: input.description }),
3887
- ...(input.detectorId != null && { detectorId: input.detectorId }),
3888
- ...(input.expression != null && { expression: input.expression }),
3889
- ...(input.language != null && { language: input.language }),
3890
- ...(input.outcomes != null && { outcomes: se_NonEmptyListOfStrings(input.outcomes, context) }),
3891
- ...(input.ruleId != null && { ruleId: input.ruleId }),
3892
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
3893
- };
3894
- };
3895
- const se_CreateVariableRequest = (input, context) => {
3896
- return {
3897
- ...(input.dataSource != null && { dataSource: input.dataSource }),
3898
- ...(input.dataType != null && { dataType: input.dataType }),
3899
- ...(input.defaultValue != null && { defaultValue: input.defaultValue }),
3900
- ...(input.description != null && { description: input.description }),
3901
- ...(input.name != null && { name: input.name }),
3902
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
3903
- ...(input.variableType != null && { variableType: input.variableType }),
3904
- };
3905
- };
3906
- const se_CsvIndexToVariableMap = (input, context) => {
3907
- return Object.entries(input).reduce((acc, [key, value]) => {
3908
- if (value === null) {
3909
- return acc;
3910
- }
3911
- acc[key] = value;
3912
- return acc;
3913
- }, {});
3914
- };
3915
- const se_DeleteBatchImportJobRequest = (input, context) => {
3916
- return {
3917
- ...(input.jobId != null && { jobId: input.jobId }),
3918
- };
3919
- };
3920
- const se_DeleteBatchPredictionJobRequest = (input, context) => {
3921
- return {
3922
- ...(input.jobId != null && { jobId: input.jobId }),
3923
- };
3924
- };
3925
- const se_DeleteDetectorRequest = (input, context) => {
3926
- return {
3927
- ...(input.detectorId != null && { detectorId: input.detectorId }),
3928
- };
3929
- };
3930
- const se_DeleteDetectorVersionRequest = (input, context) => {
3931
- return {
3932
- ...(input.detectorId != null && { detectorId: input.detectorId }),
3933
- ...(input.detectorVersionId != null && { detectorVersionId: input.detectorVersionId }),
3934
- };
3935
- };
3936
- const se_DeleteEntityTypeRequest = (input, context) => {
3937
- return {
3938
- ...(input.name != null && { name: input.name }),
3939
- };
3940
- };
3941
- const se_DeleteEventRequest = (input, context) => {
3942
- return {
3943
- ...(input.deleteAuditHistory != null && { deleteAuditHistory: input.deleteAuditHistory }),
3944
- ...(input.eventId != null && { eventId: input.eventId }),
3945
- ...(input.eventTypeName != null && { eventTypeName: input.eventTypeName }),
3946
- };
3947
- };
3948
- const se_DeleteEventsByEventTypeRequest = (input, context) => {
3949
- return {
3950
- ...(input.eventTypeName != null && { eventTypeName: input.eventTypeName }),
3951
- };
3952
- };
3953
- const se_DeleteEventTypeRequest = (input, context) => {
3954
- return {
3955
- ...(input.name != null && { name: input.name }),
3956
- };
3957
- };
3958
- const se_DeleteExternalModelRequest = (input, context) => {
3959
- return {
3960
- ...(input.modelEndpoint != null && { modelEndpoint: input.modelEndpoint }),
3961
- };
3962
- };
3963
- const se_DeleteLabelRequest = (input, context) => {
3964
- return {
3965
- ...(input.name != null && { name: input.name }),
3966
- };
3967
- };
3968
- const se_DeleteListRequest = (input, context) => {
3969
- return {
3970
- ...(input.name != null && { name: input.name }),
3971
- };
3972
- };
3973
- const se_DeleteModelRequest = (input, context) => {
3974
- return {
3975
- ...(input.modelId != null && { modelId: input.modelId }),
3976
- ...(input.modelType != null && { modelType: input.modelType }),
3977
- };
3978
- };
3979
- const se_DeleteModelVersionRequest = (input, context) => {
3980
- return {
3981
- ...(input.modelId != null && { modelId: input.modelId }),
3982
- ...(input.modelType != null && { modelType: input.modelType }),
3983
- ...(input.modelVersionNumber != null && { modelVersionNumber: input.modelVersionNumber }),
3984
- };
3985
- };
3986
- const se_DeleteOutcomeRequest = (input, context) => {
3987
- return {
3988
- ...(input.name != null && { name: input.name }),
3989
- };
3990
- };
3991
- const se_DeleteRuleRequest = (input, context) => {
3992
- return {
3993
- ...(input.rule != null && { rule: se_Rule(input.rule, context) }),
3994
- };
3995
- };
3996
- const se_DeleteVariableRequest = (input, context) => {
3997
- return {
3998
- ...(input.name != null && { name: input.name }),
3999
- };
4000
- };
4001
- const se_DescribeDetectorRequest = (input, context) => {
4002
- return {
4003
- ...(input.detectorId != null && { detectorId: input.detectorId }),
4004
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4005
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4006
- };
4007
- };
4008
- const se_DescribeModelVersionsRequest = (input, context) => {
4009
- return {
4010
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4011
- ...(input.modelId != null && { modelId: input.modelId }),
4012
- ...(input.modelType != null && { modelType: input.modelType }),
4013
- ...(input.modelVersionNumber != null && { modelVersionNumber: input.modelVersionNumber }),
4014
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4015
- };
4016
- };
4017
- const se_ElementsList = (input, context) => {
4018
- return input
4019
- .filter((e) => e != null)
4020
- .map((entry) => {
4021
- return entry;
4022
- });
4023
- };
4024
- const se_Entity = (input, context) => {
4025
- return {
4026
- ...(input.entityId != null && { entityId: input.entityId }),
4027
- ...(input.entityType != null && { entityType: input.entityType }),
4028
- };
4029
- };
4030
- const se_EventVariableMap = (input, context) => {
4031
- return Object.entries(input).reduce((acc, [key, value]) => {
4032
- if (value === null) {
4033
- return acc;
4034
- }
4035
- acc[key] = value;
4036
- return acc;
4037
- }, {});
4038
- };
4039
- const se_ExternalEventsDetail = (input, context) => {
4040
- return {
4041
- ...(input.dataAccessRoleArn != null && { dataAccessRoleArn: input.dataAccessRoleArn }),
4042
- ...(input.dataLocation != null && { dataLocation: input.dataLocation }),
4043
- };
4044
- };
4045
3720
  const se_ExternalModelEndpointDataBlobMap = (input, context) => {
4046
3721
  return Object.entries(input).reduce((acc, [key, value]) => {
4047
3722
  if (value === null) {
@@ -4051,1419 +3726,130 @@ const se_ExternalModelEndpointDataBlobMap = (input, context) => {
4051
3726
  return acc;
4052
3727
  }, {});
4053
3728
  };
4054
- const se_FilterCondition = (input, context) => {
4055
- return {
4056
- ...(input.value != null && { value: input.value }),
4057
- };
4058
- };
4059
- const se_GetBatchImportJobsRequest = (input, context) => {
4060
- return {
4061
- ...(input.jobId != null && { jobId: input.jobId }),
4062
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4063
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4064
- };
4065
- };
4066
- const se_GetBatchPredictionJobsRequest = (input, context) => {
4067
- return {
4068
- ...(input.jobId != null && { jobId: input.jobId }),
4069
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4070
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4071
- };
4072
- };
4073
- const se_GetDeleteEventsByEventTypeStatusRequest = (input, context) => {
4074
- return {
4075
- ...(input.eventTypeName != null && { eventTypeName: input.eventTypeName }),
4076
- };
4077
- };
4078
- const se_GetDetectorsRequest = (input, context) => {
4079
- return {
4080
- ...(input.detectorId != null && { detectorId: input.detectorId }),
4081
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4082
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4083
- };
4084
- };
4085
- const se_GetDetectorVersionRequest = (input, context) => {
4086
- return {
4087
- ...(input.detectorId != null && { detectorId: input.detectorId }),
4088
- ...(input.detectorVersionId != null && { detectorVersionId: input.detectorVersionId }),
4089
- };
4090
- };
4091
- const se_GetEntityTypesRequest = (input, context) => {
4092
- return {
4093
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4094
- ...(input.name != null && { name: input.name }),
4095
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4096
- };
4097
- };
4098
- const se_GetEventPredictionMetadataRequest = (input, context) => {
4099
- return {
4100
- ...(input.detectorId != null && { detectorId: input.detectorId }),
4101
- ...(input.detectorVersionId != null && { detectorVersionId: input.detectorVersionId }),
4102
- ...(input.eventId != null && { eventId: input.eventId }),
4103
- ...(input.eventTypeName != null && { eventTypeName: input.eventTypeName }),
4104
- ...(input.predictionTimestamp != null && { predictionTimestamp: input.predictionTimestamp }),
4105
- };
4106
- };
4107
3729
  const se_GetEventPredictionRequest = (input, context) => {
4108
- return {
4109
- ...(input.detectorId != null && { detectorId: input.detectorId }),
4110
- ...(input.detectorVersionId != null && { detectorVersionId: input.detectorVersionId }),
4111
- ...(input.entities != null && { entities: se_listOfEntities(input.entities, context) }),
4112
- ...(input.eventId != null && { eventId: input.eventId }),
4113
- ...(input.eventTimestamp != null && { eventTimestamp: input.eventTimestamp }),
4114
- ...(input.eventTypeName != null && { eventTypeName: input.eventTypeName }),
4115
- ...(input.eventVariables != null && { eventVariables: se_EventVariableMap(input.eventVariables, context) }),
4116
- ...(input.externalModelEndpointDataBlobs != null && {
4117
- externalModelEndpointDataBlobs: se_ExternalModelEndpointDataBlobMap(input.externalModelEndpointDataBlobs, context),
4118
- }),
4119
- };
4120
- };
4121
- const se_GetEventRequest = (input, context) => {
4122
- return {
4123
- ...(input.eventId != null && { eventId: input.eventId }),
4124
- ...(input.eventTypeName != null && { eventTypeName: input.eventTypeName }),
4125
- };
4126
- };
4127
- const se_GetEventTypesRequest = (input, context) => {
4128
- return {
4129
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4130
- ...(input.name != null && { name: input.name }),
4131
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4132
- };
4133
- };
4134
- const se_GetExternalModelsRequest = (input, context) => {
4135
- return {
4136
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4137
- ...(input.modelEndpoint != null && { modelEndpoint: input.modelEndpoint }),
4138
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4139
- };
4140
- };
4141
- const se_GetLabelsRequest = (input, context) => {
4142
- return {
4143
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4144
- ...(input.name != null && { name: input.name }),
4145
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4146
- };
4147
- };
4148
- const se_GetListElementsRequest = (input, context) => {
4149
- return {
4150
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4151
- ...(input.name != null && { name: input.name }),
4152
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4153
- };
4154
- };
4155
- const se_GetListsMetadataRequest = (input, context) => {
4156
- return {
4157
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4158
- ...(input.name != null && { name: input.name }),
4159
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4160
- };
4161
- };
4162
- const se_GetModelsRequest = (input, context) => {
4163
- return {
4164
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4165
- ...(input.modelId != null && { modelId: input.modelId }),
4166
- ...(input.modelType != null && { modelType: input.modelType }),
4167
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4168
- };
4169
- };
4170
- const se_GetModelVersionRequest = (input, context) => {
4171
- return {
4172
- ...(input.modelId != null && { modelId: input.modelId }),
4173
- ...(input.modelType != null && { modelType: input.modelType }),
4174
- ...(input.modelVersionNumber != null && { modelVersionNumber: input.modelVersionNumber }),
4175
- };
4176
- };
4177
- const se_GetOutcomesRequest = (input, context) => {
4178
- return {
4179
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4180
- ...(input.name != null && { name: input.name }),
4181
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4182
- };
4183
- };
4184
- const se_GetRulesRequest = (input, context) => {
4185
- return {
4186
- ...(input.detectorId != null && { detectorId: input.detectorId }),
4187
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4188
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4189
- ...(input.ruleId != null && { ruleId: input.ruleId }),
4190
- ...(input.ruleVersion != null && { ruleVersion: input.ruleVersion }),
4191
- };
4192
- };
4193
- const se_GetVariablesRequest = (input, context) => {
4194
- return {
4195
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4196
- ...(input.name != null && { name: input.name }),
4197
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4198
- };
4199
- };
4200
- const se_IngestedEventsDetail = (input, context) => {
4201
- return {
4202
- ...(input.ingestedEventsTimeWindow != null && {
4203
- ingestedEventsTimeWindow: se_IngestedEventsTimeWindow(input.ingestedEventsTimeWindow, context),
4204
- }),
4205
- };
4206
- };
4207
- const se_IngestedEventsTimeWindow = (input, context) => {
4208
- return {
4209
- ...(input.endTime != null && { endTime: input.endTime }),
4210
- ...(input.startTime != null && { startTime: input.startTime }),
4211
- };
4212
- };
4213
- const se_JsonKeyToVariableMap = (input, context) => {
4214
- return Object.entries(input).reduce((acc, [key, value]) => {
4215
- if (value === null) {
4216
- return acc;
4217
- }
4218
- acc[key] = value;
4219
- return acc;
4220
- }, {});
4221
- };
4222
- const se_labelMapper = (input, context) => {
4223
- return Object.entries(input).reduce((acc, [key, value]) => {
4224
- if (value === null) {
4225
- return acc;
4226
- }
4227
- acc[key] = se_ListOfStrings(value, context);
4228
- return acc;
4229
- }, {});
4230
- };
4231
- const se_LabelSchema = (input, context) => {
4232
- return {
4233
- ...(input.labelMapper != null && { labelMapper: se_labelMapper(input.labelMapper, context) }),
4234
- ...(input.unlabeledEventsTreatment != null && { unlabeledEventsTreatment: input.unlabeledEventsTreatment }),
4235
- };
4236
- };
4237
- const se_ListEventPredictionsRequest = (input, context) => {
4238
- return {
4239
- ...(input.detectorId != null && { detectorId: se_FilterCondition(input.detectorId, context) }),
4240
- ...(input.detectorVersionId != null && { detectorVersionId: se_FilterCondition(input.detectorVersionId, context) }),
4241
- ...(input.eventId != null && { eventId: se_FilterCondition(input.eventId, context) }),
4242
- ...(input.eventType != null && { eventType: se_FilterCondition(input.eventType, context) }),
4243
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4244
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4245
- ...(input.predictionTimeRange != null && {
4246
- predictionTimeRange: se_PredictionTimeRange(input.predictionTimeRange, context),
4247
- }),
4248
- };
4249
- };
4250
- const se_listOfEntities = (input, context) => {
4251
- return input
4252
- .filter((e) => e != null)
4253
- .map((entry) => {
4254
- return se_Entity(entry, context);
3730
+ return take(input, {
3731
+ detectorId: [],
3732
+ detectorVersionId: [],
3733
+ entities: _json,
3734
+ eventId: [],
3735
+ eventTimestamp: [],
3736
+ eventTypeName: [],
3737
+ eventVariables: _json,
3738
+ externalModelEndpointDataBlobs: (_) => se_ExternalModelEndpointDataBlobMap(_, context),
4255
3739
  });
4256
3740
  };
4257
- const se_ListOfModelVersions = (input, context) => {
4258
- return input
4259
- .filter((e) => e != null)
4260
- .map((entry) => {
4261
- return se_ModelVersion(entry, context);
3741
+ const se_ModelEndpointDataBlob = (input, context) => {
3742
+ return take(input, {
3743
+ byteBuffer: context.base64Encoder,
3744
+ contentType: [],
4262
3745
  });
4263
3746
  };
4264
- const se_ListOfStrings = (input, context) => {
4265
- return input
4266
- .filter((e) => e != null)
4267
- .map((entry) => {
4268
- return entry;
3747
+ const de_AggregatedLogOddsMetric = (output, context) => {
3748
+ return take(output, {
3749
+ aggregatedVariablesImportance: __limitedParseFloat32,
3750
+ variableNames: _json,
4269
3751
  });
4270
3752
  };
4271
- const se_ListTagsForResourceRequest = (input, context) => {
4272
- return {
4273
- ...(input.maxResults != null && { maxResults: input.maxResults }),
4274
- ...(input.nextToken != null && { nextToken: input.nextToken }),
4275
- ...(input.resourceARN != null && { resourceARN: input.resourceARN }),
4276
- };
4277
- };
4278
- const se_ModelEndpointDataBlob = (input, context) => {
4279
- return {
4280
- ...(input.byteBuffer != null && { byteBuffer: context.base64Encoder(input.byteBuffer) }),
4281
- ...(input.contentType != null && { contentType: input.contentType }),
4282
- };
4283
- };
4284
- const se_ModelInputConfiguration = (input, context) => {
4285
- return {
4286
- ...(input.csvInputTemplate != null && { csvInputTemplate: input.csvInputTemplate }),
4287
- ...(input.eventTypeName != null && { eventTypeName: input.eventTypeName }),
4288
- ...(input.format != null && { format: input.format }),
4289
- ...(input.jsonInputTemplate != null && { jsonInputTemplate: input.jsonInputTemplate }),
4290
- ...(input.useEventVariables != null && { useEventVariables: input.useEventVariables }),
4291
- };
4292
- };
4293
- const se_ModelOutputConfiguration = (input, context) => {
4294
- return {
4295
- ...(input.csvIndexToVariableMap != null && {
4296
- csvIndexToVariableMap: se_CsvIndexToVariableMap(input.csvIndexToVariableMap, context),
4297
- }),
4298
- ...(input.format != null && { format: input.format }),
4299
- ...(input.jsonKeyToVariableMap != null && {
4300
- jsonKeyToVariableMap: se_JsonKeyToVariableMap(input.jsonKeyToVariableMap, context),
4301
- }),
4302
- };
4303
- };
4304
- const se_ModelVersion = (input, context) => {
4305
- return {
4306
- ...(input.arn != null && { arn: input.arn }),
4307
- ...(input.modelId != null && { modelId: input.modelId }),
4308
- ...(input.modelType != null && { modelType: input.modelType }),
4309
- ...(input.modelVersionNumber != null && { modelVersionNumber: input.modelVersionNumber }),
4310
- };
4311
- };
4312
- const se_NameList = (input, context) => {
4313
- return input
4314
- .filter((e) => e != null)
4315
- .map((entry) => {
4316
- return entry;
3753
+ const de_AggregatedVariablesImpactExplanation = (output, context) => {
3754
+ return take(output, {
3755
+ eventVariableNames: _json,
3756
+ logOddsImpact: __limitedParseFloat32,
3757
+ relativeImpact: __expectString,
4317
3758
  });
4318
3759
  };
4319
- const se_NonEmptyListOfStrings = (input, context) => {
4320
- return input
4321
- .filter((e) => e != null)
4322
- .map((entry) => {
4323
- return entry;
3760
+ const de_AggregatedVariablesImportanceMetrics = (output, context) => {
3761
+ return take(output, {
3762
+ logOddsMetrics: (_) => de_ListOfAggregatedLogOddsMetrics(_, context),
4324
3763
  });
4325
3764
  };
4326
- const se_PredictionTimeRange = (input, context) => {
4327
- return {
4328
- ...(input.endTime != null && { endTime: input.endTime }),
4329
- ...(input.startTime != null && { startTime: input.startTime }),
4330
- };
4331
- };
4332
- const se_PutDetectorRequest = (input, context) => {
4333
- return {
4334
- ...(input.description != null && { description: input.description }),
4335
- ...(input.detectorId != null && { detectorId: input.detectorId }),
4336
- ...(input.eventTypeName != null && { eventTypeName: input.eventTypeName }),
4337
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
4338
- };
4339
- };
4340
- const se_PutEntityTypeRequest = (input, context) => {
4341
- return {
4342
- ...(input.description != null && { description: input.description }),
4343
- ...(input.name != null && { name: input.name }),
4344
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
4345
- };
4346
- };
4347
- const se_PutEventTypeRequest = (input, context) => {
4348
- return {
4349
- ...(input.description != null && { description: input.description }),
4350
- ...(input.entityTypes != null && { entityTypes: se_NonEmptyListOfStrings(input.entityTypes, context) }),
4351
- ...(input.eventIngestion != null && { eventIngestion: input.eventIngestion }),
4352
- ...(input.eventVariables != null && { eventVariables: se_NonEmptyListOfStrings(input.eventVariables, context) }),
4353
- ...(input.labels != null && { labels: se_ListOfStrings(input.labels, context) }),
4354
- ...(input.name != null && { name: input.name }),
4355
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
4356
- };
4357
- };
4358
- const se_PutExternalModelRequest = (input, context) => {
4359
- return {
4360
- ...(input.inputConfiguration != null && {
4361
- inputConfiguration: se_ModelInputConfiguration(input.inputConfiguration, context),
4362
- }),
4363
- ...(input.invokeModelEndpointRoleArn != null && { invokeModelEndpointRoleArn: input.invokeModelEndpointRoleArn }),
4364
- ...(input.modelEndpoint != null && { modelEndpoint: input.modelEndpoint }),
4365
- ...(input.modelEndpointStatus != null && { modelEndpointStatus: input.modelEndpointStatus }),
4366
- ...(input.modelSource != null && { modelSource: input.modelSource }),
4367
- ...(input.outputConfiguration != null && {
4368
- outputConfiguration: se_ModelOutputConfiguration(input.outputConfiguration, context),
4369
- }),
4370
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
4371
- };
4372
- };
4373
- const se_PutKMSEncryptionKeyRequest = (input, context) => {
4374
- return {
4375
- ...(input.kmsEncryptionKeyArn != null && { kmsEncryptionKeyArn: input.kmsEncryptionKeyArn }),
4376
- };
4377
- };
4378
- const se_PutLabelRequest = (input, context) => {
4379
- return {
4380
- ...(input.description != null && { description: input.description }),
4381
- ...(input.name != null && { name: input.name }),
4382
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
4383
- };
4384
- };
4385
- const se_PutOutcomeRequest = (input, context) => {
4386
- return {
4387
- ...(input.description != null && { description: input.description }),
4388
- ...(input.name != null && { name: input.name }),
4389
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
4390
- };
4391
- };
4392
- const se_Rule = (input, context) => {
4393
- return {
4394
- ...(input.detectorId != null && { detectorId: input.detectorId }),
4395
- ...(input.ruleId != null && { ruleId: input.ruleId }),
4396
- ...(input.ruleVersion != null && { ruleVersion: input.ruleVersion }),
4397
- };
3765
+ const de_ATIMetricDataPoint = (output, context) => {
3766
+ return take(output, {
3767
+ adr: __limitedParseFloat32,
3768
+ atodr: __limitedParseFloat32,
3769
+ cr: __limitedParseFloat32,
3770
+ threshold: __limitedParseFloat32,
3771
+ });
4398
3772
  };
4399
- const se_RuleList = (input, context) => {
4400
- return input
3773
+ const de_ATIMetricDataPointsList = (output, context) => {
3774
+ const retVal = (output || [])
4401
3775
  .filter((e) => e != null)
4402
3776
  .map((entry) => {
4403
- return se_Rule(entry, context);
3777
+ return de_ATIMetricDataPoint(entry, context);
4404
3778
  });
3779
+ return retVal;
4405
3780
  };
4406
- const se_SendEventRequest = (input, context) => {
4407
- return {
4408
- ...(input.assignedLabel != null && { assignedLabel: input.assignedLabel }),
4409
- ...(input.entities != null && { entities: se_listOfEntities(input.entities, context) }),
4410
- ...(input.eventId != null && { eventId: input.eventId }),
4411
- ...(input.eventTimestamp != null && { eventTimestamp: input.eventTimestamp }),
4412
- ...(input.eventTypeName != null && { eventTypeName: input.eventTypeName }),
4413
- ...(input.eventVariables != null && { eventVariables: se_EventVariableMap(input.eventVariables, context) }),
4414
- ...(input.labelTimestamp != null && { labelTimestamp: input.labelTimestamp }),
4415
- };
4416
- };
4417
- const se_Tag = (input, context) => {
4418
- return {
4419
- ...(input.key != null && { key: input.key }),
4420
- ...(input.value != null && { value: input.value }),
4421
- };
4422
- };
4423
- const se_tagKeyList = (input, context) => {
4424
- return input
4425
- .filter((e) => e != null)
4426
- .map((entry) => {
4427
- return entry;
4428
- });
4429
- };
4430
- const se_tagList = (input, context) => {
4431
- return input
4432
- .filter((e) => e != null)
4433
- .map((entry) => {
4434
- return se_Tag(entry, context);
4435
- });
4436
- };
4437
- const se_TagResourceRequest = (input, context) => {
4438
- return {
4439
- ...(input.resourceARN != null && { resourceARN: input.resourceARN }),
4440
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
4441
- };
4442
- };
4443
- const se_TrainingDataSchema = (input, context) => {
4444
- return {
4445
- ...(input.labelSchema != null && { labelSchema: se_LabelSchema(input.labelSchema, context) }),
4446
- ...(input.modelVariables != null && { modelVariables: se_ListOfStrings(input.modelVariables, context) }),
4447
- };
4448
- };
4449
- const se_UntagResourceRequest = (input, context) => {
4450
- return {
4451
- ...(input.resourceARN != null && { resourceARN: input.resourceARN }),
4452
- ...(input.tagKeys != null && { tagKeys: se_tagKeyList(input.tagKeys, context) }),
4453
- };
4454
- };
4455
- const se_UpdateDetectorVersionMetadataRequest = (input, context) => {
4456
- return {
4457
- ...(input.description != null && { description: input.description }),
4458
- ...(input.detectorId != null && { detectorId: input.detectorId }),
4459
- ...(input.detectorVersionId != null && { detectorVersionId: input.detectorVersionId }),
4460
- };
4461
- };
4462
- const se_UpdateDetectorVersionRequest = (input, context) => {
4463
- return {
4464
- ...(input.description != null && { description: input.description }),
4465
- ...(input.detectorId != null && { detectorId: input.detectorId }),
4466
- ...(input.detectorVersionId != null && { detectorVersionId: input.detectorVersionId }),
4467
- ...(input.externalModelEndpoints != null && {
4468
- externalModelEndpoints: se_ListOfStrings(input.externalModelEndpoints, context),
4469
- }),
4470
- ...(input.modelVersions != null && { modelVersions: se_ListOfModelVersions(input.modelVersions, context) }),
4471
- ...(input.ruleExecutionMode != null && { ruleExecutionMode: input.ruleExecutionMode }),
4472
- ...(input.rules != null && { rules: se_RuleList(input.rules, context) }),
4473
- };
4474
- };
4475
- const se_UpdateDetectorVersionStatusRequest = (input, context) => {
4476
- return {
4477
- ...(input.detectorId != null && { detectorId: input.detectorId }),
4478
- ...(input.detectorVersionId != null && { detectorVersionId: input.detectorVersionId }),
4479
- ...(input.status != null && { status: input.status }),
4480
- };
4481
- };
4482
- const se_UpdateEventLabelRequest = (input, context) => {
4483
- return {
4484
- ...(input.assignedLabel != null && { assignedLabel: input.assignedLabel }),
4485
- ...(input.eventId != null && { eventId: input.eventId }),
4486
- ...(input.eventTypeName != null && { eventTypeName: input.eventTypeName }),
4487
- ...(input.labelTimestamp != null && { labelTimestamp: input.labelTimestamp }),
4488
- };
4489
- };
4490
- const se_UpdateListRequest = (input, context) => {
4491
- return {
4492
- ...(input.description != null && { description: input.description }),
4493
- ...(input.elements != null && { elements: se_ElementsList(input.elements, context) }),
4494
- ...(input.name != null && { name: input.name }),
4495
- ...(input.updateMode != null && { updateMode: input.updateMode }),
4496
- ...(input.variableType != null && { variableType: input.variableType }),
4497
- };
4498
- };
4499
- const se_UpdateModelRequest = (input, context) => {
4500
- return {
4501
- ...(input.description != null && { description: input.description }),
4502
- ...(input.modelId != null && { modelId: input.modelId }),
4503
- ...(input.modelType != null && { modelType: input.modelType }),
4504
- };
4505
- };
4506
- const se_UpdateModelVersionRequest = (input, context) => {
4507
- return {
4508
- ...(input.externalEventsDetail != null && {
4509
- externalEventsDetail: se_ExternalEventsDetail(input.externalEventsDetail, context),
4510
- }),
4511
- ...(input.ingestedEventsDetail != null && {
4512
- ingestedEventsDetail: se_IngestedEventsDetail(input.ingestedEventsDetail, context),
4513
- }),
4514
- ...(input.majorVersionNumber != null && { majorVersionNumber: input.majorVersionNumber }),
4515
- ...(input.modelId != null && { modelId: input.modelId }),
4516
- ...(input.modelType != null && { modelType: input.modelType }),
4517
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
4518
- };
4519
- };
4520
- const se_UpdateModelVersionStatusRequest = (input, context) => {
4521
- return {
4522
- ...(input.modelId != null && { modelId: input.modelId }),
4523
- ...(input.modelType != null && { modelType: input.modelType }),
4524
- ...(input.modelVersionNumber != null && { modelVersionNumber: input.modelVersionNumber }),
4525
- ...(input.status != null && { status: input.status }),
4526
- };
4527
- };
4528
- const se_UpdateRuleMetadataRequest = (input, context) => {
4529
- return {
4530
- ...(input.description != null && { description: input.description }),
4531
- ...(input.rule != null && { rule: se_Rule(input.rule, context) }),
4532
- };
4533
- };
4534
- const se_UpdateRuleVersionRequest = (input, context) => {
4535
- return {
4536
- ...(input.description != null && { description: input.description }),
4537
- ...(input.expression != null && { expression: input.expression }),
4538
- ...(input.language != null && { language: input.language }),
4539
- ...(input.outcomes != null && { outcomes: se_NonEmptyListOfStrings(input.outcomes, context) }),
4540
- ...(input.rule != null && { rule: se_Rule(input.rule, context) }),
4541
- ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
4542
- };
4543
- };
4544
- const se_UpdateVariableRequest = (input, context) => {
4545
- return {
4546
- ...(input.defaultValue != null && { defaultValue: input.defaultValue }),
4547
- ...(input.description != null && { description: input.description }),
4548
- ...(input.name != null && { name: input.name }),
4549
- ...(input.variableType != null && { variableType: input.variableType }),
4550
- };
4551
- };
4552
- const se_VariableEntry = (input, context) => {
4553
- return {
4554
- ...(input.dataSource != null && { dataSource: input.dataSource }),
4555
- ...(input.dataType != null && { dataType: input.dataType }),
4556
- ...(input.defaultValue != null && { defaultValue: input.defaultValue }),
4557
- ...(input.description != null && { description: input.description }),
4558
- ...(input.name != null && { name: input.name }),
4559
- ...(input.variableType != null && { variableType: input.variableType }),
4560
- };
4561
- };
4562
- const se_VariableEntryList = (input, context) => {
4563
- return input
4564
- .filter((e) => e != null)
4565
- .map((entry) => {
4566
- return se_VariableEntry(entry, context);
4567
- });
4568
- };
4569
- const de_AccessDeniedException = (output, context) => {
4570
- return {
4571
- message: __expectString(output.message),
4572
- };
4573
- };
4574
- const de_AggregatedLogOddsMetric = (output, context) => {
4575
- return {
4576
- aggregatedVariablesImportance: __limitedParseFloat32(output.aggregatedVariablesImportance),
4577
- variableNames: output.variableNames != null ? de_ListOfStrings(output.variableNames, context) : undefined,
4578
- };
4579
- };
4580
- const de_AggregatedVariablesImpactExplanation = (output, context) => {
4581
- return {
4582
- eventVariableNames: output.eventVariableNames != null ? de_ListOfStrings(output.eventVariableNames, context) : undefined,
4583
- logOddsImpact: __limitedParseFloat32(output.logOddsImpact),
4584
- relativeImpact: __expectString(output.relativeImpact),
4585
- };
4586
- };
4587
- const de_AggregatedVariablesImportanceMetrics = (output, context) => {
4588
- return {
4589
- logOddsMetrics: output.logOddsMetrics != null ? de_ListOfAggregatedLogOddsMetrics(output.logOddsMetrics, context) : undefined,
4590
- };
4591
- };
4592
- const de_AllowDenyList = (output, context) => {
4593
- return {
4594
- arn: __expectString(output.arn),
4595
- createdTime: __expectString(output.createdTime),
4596
- description: __expectString(output.description),
4597
- name: __expectString(output.name),
4598
- updatedTime: __expectString(output.updatedTime),
4599
- variableType: __expectString(output.variableType),
4600
- };
4601
- };
4602
- const de_AllowDenyLists = (output, context) => {
4603
- const retVal = (output || [])
4604
- .filter((e) => e != null)
4605
- .map((entry) => {
4606
- if (entry === null) {
4607
- return null;
4608
- }
4609
- return de_AllowDenyList(entry, context);
4610
- });
4611
- return retVal;
4612
- };
4613
- const de_ATIMetricDataPoint = (output, context) => {
4614
- return {
4615
- adr: __limitedParseFloat32(output.adr),
4616
- atodr: __limitedParseFloat32(output.atodr),
4617
- cr: __limitedParseFloat32(output.cr),
4618
- threshold: __limitedParseFloat32(output.threshold),
4619
- };
4620
- };
4621
- const de_ATIMetricDataPointsList = (output, context) => {
4622
- const retVal = (output || [])
4623
- .filter((e) => e != null)
4624
- .map((entry) => {
4625
- if (entry === null) {
4626
- return null;
4627
- }
4628
- return de_ATIMetricDataPoint(entry, context);
4629
- });
4630
- return retVal;
4631
- };
4632
- const de_ATIModelPerformance = (output, context) => {
4633
- return {
4634
- asi: __limitedParseFloat32(output.asi),
4635
- };
3781
+ const de_ATIModelPerformance = (output, context) => {
3782
+ return take(output, {
3783
+ asi: __limitedParseFloat32,
3784
+ });
4636
3785
  };
4637
3786
  const de_ATITrainingMetricsValue = (output, context) => {
4638
- return {
4639
- metricDataPoints: output.metricDataPoints != null ? de_ATIMetricDataPointsList(output.metricDataPoints, context) : undefined,
4640
- modelPerformance: output.modelPerformance != null ? de_ATIModelPerformance(output.modelPerformance, context) : undefined,
4641
- };
4642
- };
4643
- const de_BatchCreateVariableError = (output, context) => {
4644
- return {
4645
- code: __expectInt32(output.code),
4646
- message: __expectString(output.message),
4647
- name: __expectString(output.name),
4648
- };
4649
- };
4650
- const de_BatchCreateVariableErrorList = (output, context) => {
4651
- const retVal = (output || [])
4652
- .filter((e) => e != null)
4653
- .map((entry) => {
4654
- if (entry === null) {
4655
- return null;
4656
- }
4657
- return de_BatchCreateVariableError(entry, context);
3787
+ return take(output, {
3788
+ metricDataPoints: (_) => de_ATIMetricDataPointsList(_, context),
3789
+ modelPerformance: (_) => de_ATIModelPerformance(_, context),
4658
3790
  });
4659
- return retVal;
4660
- };
4661
- const de_BatchCreateVariableResult = (output, context) => {
4662
- return {
4663
- errors: output.errors != null ? de_BatchCreateVariableErrorList(output.errors, context) : undefined,
4664
- };
4665
- };
4666
- const de_BatchGetVariableError = (output, context) => {
4667
- return {
4668
- code: __expectInt32(output.code),
4669
- message: __expectString(output.message),
4670
- name: __expectString(output.name),
4671
- };
4672
- };
4673
- const de_BatchGetVariableErrorList = (output, context) => {
4674
- const retVal = (output || [])
4675
- .filter((e) => e != null)
4676
- .map((entry) => {
4677
- if (entry === null) {
4678
- return null;
4679
- }
4680
- return de_BatchGetVariableError(entry, context);
4681
- });
4682
- return retVal;
4683
- };
4684
- const de_BatchGetVariableResult = (output, context) => {
4685
- return {
4686
- errors: output.errors != null ? de_BatchGetVariableErrorList(output.errors, context) : undefined,
4687
- variables: output.variables != null ? de_VariableList(output.variables, context) : undefined,
4688
- };
4689
- };
4690
- const de_BatchImport = (output, context) => {
4691
- return {
4692
- arn: __expectString(output.arn),
4693
- completionTime: __expectString(output.completionTime),
4694
- eventTypeName: __expectString(output.eventTypeName),
4695
- failedRecordsCount: __expectInt32(output.failedRecordsCount),
4696
- failureReason: __expectString(output.failureReason),
4697
- iamRoleArn: __expectString(output.iamRoleArn),
4698
- inputPath: __expectString(output.inputPath),
4699
- jobId: __expectString(output.jobId),
4700
- outputPath: __expectString(output.outputPath),
4701
- processedRecordsCount: __expectInt32(output.processedRecordsCount),
4702
- startTime: __expectString(output.startTime),
4703
- status: __expectString(output.status),
4704
- totalRecordsCount: __expectInt32(output.totalRecordsCount),
4705
- };
4706
- };
4707
- const de_BatchImportList = (output, context) => {
4708
- const retVal = (output || [])
4709
- .filter((e) => e != null)
4710
- .map((entry) => {
4711
- if (entry === null) {
4712
- return null;
4713
- }
4714
- return de_BatchImport(entry, context);
4715
- });
4716
- return retVal;
4717
- };
4718
- const de_BatchPrediction = (output, context) => {
4719
- return {
4720
- arn: __expectString(output.arn),
4721
- completionTime: __expectString(output.completionTime),
4722
- detectorName: __expectString(output.detectorName),
4723
- detectorVersion: __expectString(output.detectorVersion),
4724
- eventTypeName: __expectString(output.eventTypeName),
4725
- failureReason: __expectString(output.failureReason),
4726
- iamRoleArn: __expectString(output.iamRoleArn),
4727
- inputPath: __expectString(output.inputPath),
4728
- jobId: __expectString(output.jobId),
4729
- lastHeartbeatTime: __expectString(output.lastHeartbeatTime),
4730
- outputPath: __expectString(output.outputPath),
4731
- processedRecordsCount: __expectInt32(output.processedRecordsCount),
4732
- startTime: __expectString(output.startTime),
4733
- status: __expectString(output.status),
4734
- totalRecordsCount: __expectInt32(output.totalRecordsCount),
4735
- };
4736
- };
4737
- const de_BatchPredictionList = (output, context) => {
4738
- const retVal = (output || [])
4739
- .filter((e) => e != null)
4740
- .map((entry) => {
4741
- if (entry === null) {
4742
- return null;
4743
- }
4744
- return de_BatchPrediction(entry, context);
4745
- });
4746
- return retVal;
4747
- };
4748
- const de_CancelBatchImportJobResult = (output, context) => {
4749
- return {};
4750
- };
4751
- const de_CancelBatchPredictionJobResult = (output, context) => {
4752
- return {};
4753
- };
4754
- const de_ConflictException = (output, context) => {
4755
- return {
4756
- message: __expectString(output.message),
4757
- };
4758
- };
4759
- const de_CreateBatchImportJobResult = (output, context) => {
4760
- return {};
4761
- };
4762
- const de_CreateBatchPredictionJobResult = (output, context) => {
4763
- return {};
4764
- };
4765
- const de_CreateDetectorVersionResult = (output, context) => {
4766
- return {
4767
- detectorId: __expectString(output.detectorId),
4768
- detectorVersionId: __expectString(output.detectorVersionId),
4769
- status: __expectString(output.status),
4770
- };
4771
- };
4772
- const de_CreateListResult = (output, context) => {
4773
- return {};
4774
- };
4775
- const de_CreateModelResult = (output, context) => {
4776
- return {};
4777
- };
4778
- const de_CreateModelVersionResult = (output, context) => {
4779
- return {
4780
- modelId: __expectString(output.modelId),
4781
- modelType: __expectString(output.modelType),
4782
- modelVersionNumber: __expectString(output.modelVersionNumber),
4783
- status: __expectString(output.status),
4784
- };
4785
- };
4786
- const de_CreateRuleResult = (output, context) => {
4787
- return {
4788
- rule: output.rule != null ? de_Rule(output.rule, context) : undefined,
4789
- };
4790
- };
4791
- const de_CreateVariableResult = (output, context) => {
4792
- return {};
4793
- };
4794
- const de_CsvIndexToVariableMap = (output, context) => {
4795
- return Object.entries(output).reduce((acc, [key, value]) => {
4796
- if (value === null) {
4797
- return acc;
4798
- }
4799
- acc[key] = __expectString(value);
4800
- return acc;
4801
- }, {});
4802
- };
4803
- const de_DataValidationMetrics = (output, context) => {
4804
- return {
4805
- fieldLevelMessages: output.fieldLevelMessages != null ? de_fieldValidationMessageList(output.fieldLevelMessages, context) : undefined,
4806
- fileLevelMessages: output.fileLevelMessages != null ? de_fileValidationMessageList(output.fileLevelMessages, context) : undefined,
4807
- };
4808
- };
4809
- const de_DeleteBatchImportJobResult = (output, context) => {
4810
- return {};
4811
- };
4812
- const de_DeleteBatchPredictionJobResult = (output, context) => {
4813
- return {};
4814
- };
4815
- const de_DeleteDetectorResult = (output, context) => {
4816
- return {};
4817
- };
4818
- const de_DeleteDetectorVersionResult = (output, context) => {
4819
- return {};
4820
- };
4821
- const de_DeleteEntityTypeResult = (output, context) => {
4822
- return {};
4823
- };
4824
- const de_DeleteEventResult = (output, context) => {
4825
- return {};
4826
- };
4827
- const de_DeleteEventsByEventTypeResult = (output, context) => {
4828
- return {
4829
- eventTypeName: __expectString(output.eventTypeName),
4830
- eventsDeletionStatus: __expectString(output.eventsDeletionStatus),
4831
- };
4832
- };
4833
- const de_DeleteEventTypeResult = (output, context) => {
4834
- return {};
4835
- };
4836
- const de_DeleteExternalModelResult = (output, context) => {
4837
- return {};
4838
- };
4839
- const de_DeleteLabelResult = (output, context) => {
4840
- return {};
4841
- };
4842
- const de_DeleteListResult = (output, context) => {
4843
- return {};
4844
- };
4845
- const de_DeleteModelResult = (output, context) => {
4846
- return {};
4847
- };
4848
- const de_DeleteModelVersionResult = (output, context) => {
4849
- return {};
4850
- };
4851
- const de_DeleteOutcomeResult = (output, context) => {
4852
- return {};
4853
- };
4854
- const de_DeleteRuleResult = (output, context) => {
4855
- return {};
4856
- };
4857
- const de_DeleteVariableResult = (output, context) => {
4858
- return {};
4859
- };
4860
- const de_DescribeDetectorResult = (output, context) => {
4861
- return {
4862
- arn: __expectString(output.arn),
4863
- detectorId: __expectString(output.detectorId),
4864
- detectorVersionSummaries: output.detectorVersionSummaries != null
4865
- ? de_DetectorVersionSummaryList(output.detectorVersionSummaries, context)
4866
- : undefined,
4867
- nextToken: __expectString(output.nextToken),
4868
- };
4869
- };
4870
- const de_DescribeModelVersionsResult = (output, context) => {
4871
- return {
4872
- modelVersionDetails: output.modelVersionDetails != null ? de_modelVersionDetailList(output.modelVersionDetails, context) : undefined,
4873
- nextToken: __expectString(output.nextToken),
4874
- };
4875
- };
4876
- const de_Detector = (output, context) => {
4877
- return {
4878
- arn: __expectString(output.arn),
4879
- createdTime: __expectString(output.createdTime),
4880
- description: __expectString(output.description),
4881
- detectorId: __expectString(output.detectorId),
4882
- eventTypeName: __expectString(output.eventTypeName),
4883
- lastUpdatedTime: __expectString(output.lastUpdatedTime),
4884
- };
4885
- };
4886
- const de_DetectorList = (output, context) => {
4887
- const retVal = (output || [])
4888
- .filter((e) => e != null)
4889
- .map((entry) => {
4890
- if (entry === null) {
4891
- return null;
4892
- }
4893
- return de_Detector(entry, context);
4894
- });
4895
- return retVal;
4896
- };
4897
- const de_DetectorVersionSummary = (output, context) => {
4898
- return {
4899
- description: __expectString(output.description),
4900
- detectorVersionId: __expectString(output.detectorVersionId),
4901
- lastUpdatedTime: __expectString(output.lastUpdatedTime),
4902
- status: __expectString(output.status),
4903
- };
4904
- };
4905
- const de_DetectorVersionSummaryList = (output, context) => {
4906
- const retVal = (output || [])
4907
- .filter((e) => e != null)
4908
- .map((entry) => {
4909
- if (entry === null) {
4910
- return null;
4911
- }
4912
- return de_DetectorVersionSummary(entry, context);
4913
- });
4914
- return retVal;
4915
- };
4916
- const de_ElementsList = (output, context) => {
4917
- const retVal = (output || [])
4918
- .filter((e) => e != null)
4919
- .map((entry) => {
4920
- if (entry === null) {
4921
- return null;
4922
- }
4923
- return __expectString(entry);
4924
- });
4925
- return retVal;
4926
- };
4927
- const de_Entity = (output, context) => {
4928
- return {
4929
- entityId: __expectString(output.entityId),
4930
- entityType: __expectString(output.entityType),
4931
- };
4932
- };
4933
- const de_EntityType = (output, context) => {
4934
- return {
4935
- arn: __expectString(output.arn),
4936
- createdTime: __expectString(output.createdTime),
4937
- description: __expectString(output.description),
4938
- lastUpdatedTime: __expectString(output.lastUpdatedTime),
4939
- name: __expectString(output.name),
4940
- };
4941
- };
4942
- const de_entityTypeList = (output, context) => {
4943
- const retVal = (output || [])
4944
- .filter((e) => e != null)
4945
- .map((entry) => {
4946
- if (entry === null) {
4947
- return null;
4948
- }
4949
- return de_EntityType(entry, context);
4950
- });
4951
- return retVal;
4952
- };
4953
- const de_EvaluatedExternalModel = (output, context) => {
4954
- return {
4955
- inputVariables: output.inputVariables != null ? de_MapOfStrings(output.inputVariables, context) : undefined,
4956
- modelEndpoint: __expectString(output.modelEndpoint),
4957
- outputVariables: output.outputVariables != null ? de_MapOfStrings(output.outputVariables, context) : undefined,
4958
- useEventVariables: __expectBoolean(output.useEventVariables),
4959
- };
4960
- };
4961
- const de_EvaluatedModelVersion = (output, context) => {
4962
- return {
4963
- evaluations: output.evaluations != null ? de_ListOfModelVersionEvaluations(output.evaluations, context) : undefined,
4964
- modelId: __expectString(output.modelId),
4965
- modelType: __expectString(output.modelType),
4966
- modelVersion: __expectString(output.modelVersion),
4967
- };
4968
- };
4969
- const de_EvaluatedRule = (output, context) => {
4970
- return {
4971
- evaluated: __expectBoolean(output.evaluated),
4972
- expression: __expectString(output.expression),
4973
- expressionWithValues: __expectString(output.expressionWithValues),
4974
- matched: __expectBoolean(output.matched),
4975
- outcomes: output.outcomes != null ? de_ListOfStrings(output.outcomes, context) : undefined,
4976
- ruleId: __expectString(output.ruleId),
4977
- ruleVersion: __expectString(output.ruleVersion),
4978
- };
4979
- };
4980
- const de_EvaluatedRuleList = (output, context) => {
4981
- const retVal = (output || [])
4982
- .filter((e) => e != null)
4983
- .map((entry) => {
4984
- if (entry === null) {
4985
- return null;
4986
- }
4987
- return de_EvaluatedRule(entry, context);
4988
- });
4989
- return retVal;
4990
- };
4991
- const de_Event = (output, context) => {
4992
- return {
4993
- currentLabel: __expectString(output.currentLabel),
4994
- entities: output.entities != null ? de_listOfEntities(output.entities, context) : undefined,
4995
- eventId: __expectString(output.eventId),
4996
- eventTimestamp: __expectString(output.eventTimestamp),
4997
- eventTypeName: __expectString(output.eventTypeName),
4998
- eventVariables: output.eventVariables != null ? de_EventAttributeMap(output.eventVariables, context) : undefined,
4999
- labelTimestamp: __expectString(output.labelTimestamp),
5000
- };
5001
- };
5002
- const de_EventAttributeMap = (output, context) => {
5003
- return Object.entries(output).reduce((acc, [key, value]) => {
5004
- if (value === null) {
5005
- return acc;
5006
- }
5007
- acc[key] = __expectString(value);
5008
- return acc;
5009
- }, {});
5010
- };
5011
- const de_EventPredictionSummary = (output, context) => {
5012
- return {
5013
- detectorId: __expectString(output.detectorId),
5014
- detectorVersionId: __expectString(output.detectorVersionId),
5015
- eventId: __expectString(output.eventId),
5016
- eventTimestamp: __expectString(output.eventTimestamp),
5017
- eventTypeName: __expectString(output.eventTypeName),
5018
- predictionTimestamp: __expectString(output.predictionTimestamp),
5019
- };
5020
- };
5021
- const de_EventType = (output, context) => {
5022
- return {
5023
- arn: __expectString(output.arn),
5024
- createdTime: __expectString(output.createdTime),
5025
- description: __expectString(output.description),
5026
- entityTypes: output.entityTypes != null ? de_NonEmptyListOfStrings(output.entityTypes, context) : undefined,
5027
- eventIngestion: __expectString(output.eventIngestion),
5028
- eventVariables: output.eventVariables != null ? de_ListOfStrings(output.eventVariables, context) : undefined,
5029
- ingestedEventStatistics: output.ingestedEventStatistics != null
5030
- ? de_IngestedEventStatistics(output.ingestedEventStatistics, context)
5031
- : undefined,
5032
- labels: output.labels != null ? de_ListOfStrings(output.labels, context) : undefined,
5033
- lastUpdatedTime: __expectString(output.lastUpdatedTime),
5034
- name: __expectString(output.name),
5035
- };
5036
- };
5037
- const de_eventTypeList = (output, context) => {
5038
- const retVal = (output || [])
5039
- .filter((e) => e != null)
5040
- .map((entry) => {
5041
- if (entry === null) {
5042
- return null;
5043
- }
5044
- return de_EventType(entry, context);
5045
- });
5046
- return retVal;
5047
- };
5048
- const de_EventVariableSummary = (output, context) => {
5049
- return {
5050
- name: __expectString(output.name),
5051
- source: __expectString(output.source),
5052
- value: __expectString(output.value),
5053
- };
5054
- };
5055
- const de_ExternalEventsDetail = (output, context) => {
5056
- return {
5057
- dataAccessRoleArn: __expectString(output.dataAccessRoleArn),
5058
- dataLocation: __expectString(output.dataLocation),
5059
- };
5060
- };
5061
- const de_ExternalModel = (output, context) => {
5062
- return {
5063
- arn: __expectString(output.arn),
5064
- createdTime: __expectString(output.createdTime),
5065
- inputConfiguration: output.inputConfiguration != null ? de_ModelInputConfiguration(output.inputConfiguration, context) : undefined,
5066
- invokeModelEndpointRoleArn: __expectString(output.invokeModelEndpointRoleArn),
5067
- lastUpdatedTime: __expectString(output.lastUpdatedTime),
5068
- modelEndpoint: __expectString(output.modelEndpoint),
5069
- modelEndpointStatus: __expectString(output.modelEndpointStatus),
5070
- modelSource: __expectString(output.modelSource),
5071
- outputConfiguration: output.outputConfiguration != null ? de_ModelOutputConfiguration(output.outputConfiguration, context) : undefined,
5072
- };
5073
- };
5074
- const de_ExternalModelList = (output, context) => {
5075
- const retVal = (output || [])
5076
- .filter((e) => e != null)
5077
- .map((entry) => {
5078
- if (entry === null) {
5079
- return null;
5080
- }
5081
- return de_ExternalModel(entry, context);
5082
- });
5083
- return retVal;
5084
- };
5085
- const de_ExternalModelOutputs = (output, context) => {
5086
- return {
5087
- externalModel: output.externalModel != null ? de_ExternalModelSummary(output.externalModel, context) : undefined,
5088
- outputs: output.outputs != null ? de_ExternalModelPredictionMap(output.outputs, context) : undefined,
5089
- };
5090
- };
5091
- const de_ExternalModelPredictionMap = (output, context) => {
5092
- return Object.entries(output).reduce((acc, [key, value]) => {
5093
- if (value === null) {
5094
- return acc;
5095
- }
5096
- acc[key] = __expectString(value);
5097
- return acc;
5098
- }, {});
5099
- };
5100
- const de_ExternalModelSummary = (output, context) => {
5101
- return {
5102
- modelEndpoint: __expectString(output.modelEndpoint),
5103
- modelSource: __expectString(output.modelSource),
5104
- };
5105
- };
5106
- const de_FieldValidationMessage = (output, context) => {
5107
- return {
5108
- content: __expectString(output.content),
5109
- fieldName: __expectString(output.fieldName),
5110
- identifier: __expectString(output.identifier),
5111
- title: __expectString(output.title),
5112
- type: __expectString(output.type),
5113
- };
5114
- };
5115
- const de_fieldValidationMessageList = (output, context) => {
5116
- const retVal = (output || [])
5117
- .filter((e) => e != null)
5118
- .map((entry) => {
5119
- if (entry === null) {
5120
- return null;
5121
- }
5122
- return de_FieldValidationMessage(entry, context);
5123
- });
5124
- return retVal;
5125
- };
5126
- const de_FileValidationMessage = (output, context) => {
5127
- return {
5128
- content: __expectString(output.content),
5129
- title: __expectString(output.title),
5130
- type: __expectString(output.type),
5131
- };
5132
- };
5133
- const de_fileValidationMessageList = (output, context) => {
5134
- const retVal = (output || [])
5135
- .filter((e) => e != null)
5136
- .map((entry) => {
5137
- if (entry === null) {
5138
- return null;
5139
- }
5140
- return de_FileValidationMessage(entry, context);
5141
- });
5142
- return retVal;
5143
- };
5144
- const de_GetBatchImportJobsResult = (output, context) => {
5145
- return {
5146
- batchImports: output.batchImports != null ? de_BatchImportList(output.batchImports, context) : undefined,
5147
- nextToken: __expectString(output.nextToken),
5148
- };
5149
- };
5150
- const de_GetBatchPredictionJobsResult = (output, context) => {
5151
- return {
5152
- batchPredictions: output.batchPredictions != null ? de_BatchPredictionList(output.batchPredictions, context) : undefined,
5153
- nextToken: __expectString(output.nextToken),
5154
- };
5155
- };
5156
- const de_GetDeleteEventsByEventTypeStatusResult = (output, context) => {
5157
- return {
5158
- eventTypeName: __expectString(output.eventTypeName),
5159
- eventsDeletionStatus: __expectString(output.eventsDeletionStatus),
5160
- };
5161
- };
5162
- const de_GetDetectorsResult = (output, context) => {
5163
- return {
5164
- detectors: output.detectors != null ? de_DetectorList(output.detectors, context) : undefined,
5165
- nextToken: __expectString(output.nextToken),
5166
- };
5167
- };
5168
- const de_GetDetectorVersionResult = (output, context) => {
5169
- return {
5170
- arn: __expectString(output.arn),
5171
- createdTime: __expectString(output.createdTime),
5172
- description: __expectString(output.description),
5173
- detectorId: __expectString(output.detectorId),
5174
- detectorVersionId: __expectString(output.detectorVersionId),
5175
- externalModelEndpoints: output.externalModelEndpoints != null ? de_ListOfStrings(output.externalModelEndpoints, context) : undefined,
5176
- lastUpdatedTime: __expectString(output.lastUpdatedTime),
5177
- modelVersions: output.modelVersions != null ? de_ListOfModelVersions(output.modelVersions, context) : undefined,
5178
- ruleExecutionMode: __expectString(output.ruleExecutionMode),
5179
- rules: output.rules != null ? de_RuleList(output.rules, context) : undefined,
5180
- status: __expectString(output.status),
5181
- };
5182
- };
5183
- const de_GetEntityTypesResult = (output, context) => {
5184
- return {
5185
- entityTypes: output.entityTypes != null ? de_entityTypeList(output.entityTypes, context) : undefined,
5186
- nextToken: __expectString(output.nextToken),
5187
- };
5188
- };
5189
- const de_GetEventPredictionMetadataResult = (output, context) => {
5190
- return {
5191
- detectorId: __expectString(output.detectorId),
5192
- detectorVersionId: __expectString(output.detectorVersionId),
5193
- detectorVersionStatus: __expectString(output.detectorVersionStatus),
5194
- entityId: __expectString(output.entityId),
5195
- entityType: __expectString(output.entityType),
5196
- evaluatedExternalModels: output.evaluatedExternalModels != null
5197
- ? de_ListOfEvaluatedExternalModels(output.evaluatedExternalModels, context)
5198
- : undefined,
5199
- evaluatedModelVersions: output.evaluatedModelVersions != null
5200
- ? de_ListOfEvaluatedModelVersions(output.evaluatedModelVersions, context)
5201
- : undefined,
5202
- eventId: __expectString(output.eventId),
5203
- eventTimestamp: __expectString(output.eventTimestamp),
5204
- eventTypeName: __expectString(output.eventTypeName),
5205
- eventVariables: output.eventVariables != null ? de_ListOfEventVariableSummaries(output.eventVariables, context) : undefined,
5206
- outcomes: output.outcomes != null ? de_ListOfStrings(output.outcomes, context) : undefined,
5207
- predictionTimestamp: __expectString(output.predictionTimestamp),
5208
- ruleExecutionMode: __expectString(output.ruleExecutionMode),
5209
- rules: output.rules != null ? de_EvaluatedRuleList(output.rules, context) : undefined,
5210
- };
5211
- };
5212
- const de_GetEventPredictionResult = (output, context) => {
5213
- return {
5214
- externalModelOutputs: output.externalModelOutputs != null
5215
- ? de_ListOfExternalModelOutputs(output.externalModelOutputs, context)
5216
- : undefined,
5217
- modelScores: output.modelScores != null ? de_ListOfModelScores(output.modelScores, context) : undefined,
5218
- ruleResults: output.ruleResults != null ? de_ListOfRuleResults(output.ruleResults, context) : undefined,
5219
- };
5220
- };
5221
- const de_GetEventResult = (output, context) => {
5222
- return {
5223
- event: output.event != null ? de_Event(output.event, context) : undefined,
5224
- };
5225
- };
5226
- const de_GetEventTypesResult = (output, context) => {
5227
- return {
5228
- eventTypes: output.eventTypes != null ? de_eventTypeList(output.eventTypes, context) : undefined,
5229
- nextToken: __expectString(output.nextToken),
5230
- };
5231
- };
5232
- const de_GetExternalModelsResult = (output, context) => {
5233
- return {
5234
- externalModels: output.externalModels != null ? de_ExternalModelList(output.externalModels, context) : undefined,
5235
- nextToken: __expectString(output.nextToken),
5236
- };
5237
- };
5238
- const de_GetKMSEncryptionKeyResult = (output, context) => {
5239
- return {
5240
- kmsKey: output.kmsKey != null ? de_KMSKey(output.kmsKey, context) : undefined,
5241
- };
5242
- };
5243
- const de_GetLabelsResult = (output, context) => {
5244
- return {
5245
- labels: output.labels != null ? de_labelList(output.labels, context) : undefined,
5246
- nextToken: __expectString(output.nextToken),
5247
- };
5248
- };
5249
- const de_GetListElementsResult = (output, context) => {
5250
- return {
5251
- elements: output.elements != null ? de_ElementsList(output.elements, context) : undefined,
5252
- nextToken: __expectString(output.nextToken),
5253
- };
5254
- };
5255
- const de_GetListsMetadataResult = (output, context) => {
5256
- return {
5257
- lists: output.lists != null ? de_AllowDenyLists(output.lists, context) : undefined,
5258
- nextToken: __expectString(output.nextToken),
5259
- };
5260
- };
5261
- const de_GetModelsResult = (output, context) => {
5262
- return {
5263
- models: output.models != null ? de_modelList(output.models, context) : undefined,
5264
- nextToken: __expectString(output.nextToken),
5265
- };
5266
- };
5267
- const de_GetModelVersionResult = (output, context) => {
5268
- return {
5269
- arn: __expectString(output.arn),
5270
- externalEventsDetail: output.externalEventsDetail != null ? de_ExternalEventsDetail(output.externalEventsDetail, context) : undefined,
5271
- ingestedEventsDetail: output.ingestedEventsDetail != null ? de_IngestedEventsDetail(output.ingestedEventsDetail, context) : undefined,
5272
- modelId: __expectString(output.modelId),
5273
- modelType: __expectString(output.modelType),
5274
- modelVersionNumber: __expectString(output.modelVersionNumber),
5275
- status: __expectString(output.status),
5276
- trainingDataSchema: output.trainingDataSchema != null ? de_TrainingDataSchema(output.trainingDataSchema, context) : undefined,
5277
- trainingDataSource: __expectString(output.trainingDataSource),
5278
- };
5279
- };
5280
- const de_GetOutcomesResult = (output, context) => {
5281
- return {
5282
- nextToken: __expectString(output.nextToken),
5283
- outcomes: output.outcomes != null ? de_OutcomeList(output.outcomes, context) : undefined,
5284
- };
5285
- };
5286
- const de_GetRulesResult = (output, context) => {
5287
- return {
5288
- nextToken: __expectString(output.nextToken),
5289
- ruleDetails: output.ruleDetails != null ? de_RuleDetailList(output.ruleDetails, context) : undefined,
5290
- };
5291
- };
5292
- const de_GetVariablesResult = (output, context) => {
5293
- return {
5294
- nextToken: __expectString(output.nextToken),
5295
- variables: output.variables != null ? de_VariableList(output.variables, context) : undefined,
5296
- };
5297
- };
5298
- const de_IngestedEventsDetail = (output, context) => {
5299
- return {
5300
- ingestedEventsTimeWindow: output.ingestedEventsTimeWindow != null
5301
- ? de_IngestedEventsTimeWindow(output.ingestedEventsTimeWindow, context)
5302
- : undefined,
5303
- };
5304
- };
5305
- const de_IngestedEventStatistics = (output, context) => {
5306
- return {
5307
- eventDataSizeInBytes: __expectLong(output.eventDataSizeInBytes),
5308
- lastUpdatedTime: __expectString(output.lastUpdatedTime),
5309
- leastRecentEvent: __expectString(output.leastRecentEvent),
5310
- mostRecentEvent: __expectString(output.mostRecentEvent),
5311
- numberOfEvents: __expectLong(output.numberOfEvents),
5312
- };
5313
- };
5314
- const de_IngestedEventsTimeWindow = (output, context) => {
5315
- return {
5316
- endTime: __expectString(output.endTime),
5317
- startTime: __expectString(output.startTime),
5318
- };
5319
- };
5320
- const de_InternalServerException = (output, context) => {
5321
- return {
5322
- message: __expectString(output.message),
5323
- };
5324
- };
5325
- const de_JsonKeyToVariableMap = (output, context) => {
5326
- return Object.entries(output).reduce((acc, [key, value]) => {
5327
- if (value === null) {
5328
- return acc;
5329
- }
5330
- acc[key] = __expectString(value);
5331
- return acc;
5332
- }, {});
5333
- };
5334
- const de_KMSKey = (output, context) => {
5335
- return {
5336
- kmsEncryptionKeyArn: __expectString(output.kmsEncryptionKeyArn),
5337
- };
5338
- };
5339
- const de_Label = (output, context) => {
5340
- return {
5341
- arn: __expectString(output.arn),
5342
- createdTime: __expectString(output.createdTime),
5343
- description: __expectString(output.description),
5344
- lastUpdatedTime: __expectString(output.lastUpdatedTime),
5345
- name: __expectString(output.name),
5346
- };
5347
- };
5348
- const de_labelList = (output, context) => {
5349
- const retVal = (output || [])
5350
- .filter((e) => e != null)
5351
- .map((entry) => {
5352
- if (entry === null) {
5353
- return null;
5354
- }
5355
- return de_Label(entry, context);
5356
- });
5357
- return retVal;
5358
- };
5359
- const de_labelMapper = (output, context) => {
5360
- return Object.entries(output).reduce((acc, [key, value]) => {
5361
- if (value === null) {
5362
- return acc;
5363
- }
5364
- acc[key] = de_ListOfStrings(value, context);
5365
- return acc;
5366
- }, {});
5367
- };
5368
- const de_LabelSchema = (output, context) => {
5369
- return {
5370
- labelMapper: output.labelMapper != null ? de_labelMapper(output.labelMapper, context) : undefined,
5371
- unlabeledEventsTreatment: __expectString(output.unlabeledEventsTreatment),
5372
- };
5373
- };
5374
- const de_ListEventPredictionsResult = (output, context) => {
5375
- return {
5376
- eventPredictionSummaries: output.eventPredictionSummaries != null
5377
- ? de_ListOfEventPredictionSummaries(output.eventPredictionSummaries, context)
5378
- : undefined,
5379
- nextToken: __expectString(output.nextToken),
5380
- };
5381
- };
5382
- const de_ListOfAggregatedLogOddsMetrics = (output, context) => {
5383
- const retVal = (output || [])
5384
- .filter((e) => e != null)
5385
- .map((entry) => {
5386
- if (entry === null) {
5387
- return null;
5388
- }
5389
- return de_AggregatedLogOddsMetric(entry, context);
5390
- });
5391
- return retVal;
5392
- };
5393
- const de_ListOfAggregatedVariablesImpactExplanations = (output, context) => {
5394
- const retVal = (output || [])
5395
- .filter((e) => e != null)
5396
- .map((entry) => {
5397
- if (entry === null) {
5398
- return null;
5399
- }
5400
- return de_AggregatedVariablesImpactExplanation(entry, context);
3791
+ };
3792
+ const de_DescribeModelVersionsResult = (output, context) => {
3793
+ return take(output, {
3794
+ modelVersionDetails: (_) => de_modelVersionDetailList(_, context),
3795
+ nextToken: __expectString,
5401
3796
  });
5402
- return retVal;
5403
3797
  };
5404
- const de_listOfEntities = (output, context) => {
5405
- const retVal = (output || [])
5406
- .filter((e) => e != null)
5407
- .map((entry) => {
5408
- if (entry === null) {
5409
- return null;
5410
- }
5411
- return de_Entity(entry, context);
3798
+ const de_EvaluatedModelVersion = (output, context) => {
3799
+ return take(output, {
3800
+ evaluations: (_) => de_ListOfModelVersionEvaluations(_, context),
3801
+ modelId: __expectString,
3802
+ modelType: __expectString,
3803
+ modelVersion: __expectString,
5412
3804
  });
5413
- return retVal;
5414
3805
  };
5415
- const de_ListOfEvaluatedExternalModels = (output, context) => {
5416
- const retVal = (output || [])
5417
- .filter((e) => e != null)
5418
- .map((entry) => {
5419
- if (entry === null) {
5420
- return null;
5421
- }
5422
- return de_EvaluatedExternalModel(entry, context);
3806
+ const de_GetEventPredictionMetadataResult = (output, context) => {
3807
+ return take(output, {
3808
+ detectorId: __expectString,
3809
+ detectorVersionId: __expectString,
3810
+ detectorVersionStatus: __expectString,
3811
+ entityId: __expectString,
3812
+ entityType: __expectString,
3813
+ evaluatedExternalModels: _json,
3814
+ evaluatedModelVersions: (_) => de_ListOfEvaluatedModelVersions(_, context),
3815
+ eventId: __expectString,
3816
+ eventTimestamp: __expectString,
3817
+ eventTypeName: __expectString,
3818
+ eventVariables: _json,
3819
+ outcomes: _json,
3820
+ predictionTimestamp: __expectString,
3821
+ ruleExecutionMode: __expectString,
3822
+ rules: _json,
5423
3823
  });
5424
- return retVal;
5425
3824
  };
5426
- const de_ListOfEvaluatedModelVersions = (output, context) => {
5427
- const retVal = (output || [])
5428
- .filter((e) => e != null)
5429
- .map((entry) => {
5430
- if (entry === null) {
5431
- return null;
5432
- }
5433
- return de_EvaluatedModelVersion(entry, context);
3825
+ const de_GetEventPredictionResult = (output, context) => {
3826
+ return take(output, {
3827
+ externalModelOutputs: _json,
3828
+ modelScores: (_) => de_ListOfModelScores(_, context),
3829
+ ruleResults: _json,
5434
3830
  });
5435
- return retVal;
5436
3831
  };
5437
- const de_ListOfEventPredictionSummaries = (output, context) => {
3832
+ const de_ListOfAggregatedLogOddsMetrics = (output, context) => {
5438
3833
  const retVal = (output || [])
5439
3834
  .filter((e) => e != null)
5440
3835
  .map((entry) => {
5441
- if (entry === null) {
5442
- return null;
5443
- }
5444
- return de_EventPredictionSummary(entry, context);
3836
+ return de_AggregatedLogOddsMetric(entry, context);
5445
3837
  });
5446
3838
  return retVal;
5447
3839
  };
5448
- const de_ListOfEventVariableSummaries = (output, context) => {
3840
+ const de_ListOfAggregatedVariablesImpactExplanations = (output, context) => {
5449
3841
  const retVal = (output || [])
5450
3842
  .filter((e) => e != null)
5451
3843
  .map((entry) => {
5452
- if (entry === null) {
5453
- return null;
5454
- }
5455
- return de_EventVariableSummary(entry, context);
3844
+ return de_AggregatedVariablesImpactExplanation(entry, context);
5456
3845
  });
5457
3846
  return retVal;
5458
3847
  };
5459
- const de_ListOfExternalModelOutputs = (output, context) => {
3848
+ const de_ListOfEvaluatedModelVersions = (output, context) => {
5460
3849
  const retVal = (output || [])
5461
3850
  .filter((e) => e != null)
5462
3851
  .map((entry) => {
5463
- if (entry === null) {
5464
- return null;
5465
- }
5466
- return de_ExternalModelOutputs(entry, context);
3852
+ return de_EvaluatedModelVersion(entry, context);
5467
3853
  });
5468
3854
  return retVal;
5469
3855
  };
@@ -5471,9 +3857,6 @@ const de_ListOfLogOddsMetrics = (output, context) => {
5471
3857
  const retVal = (output || [])
5472
3858
  .filter((e) => e != null)
5473
3859
  .map((entry) => {
5474
- if (entry === null) {
5475
- return null;
5476
- }
5477
3860
  return de_LogOddsMetric(entry, context);
5478
3861
  });
5479
3862
  return retVal;
@@ -5482,9 +3865,6 @@ const de_ListOfModelScores = (output, context) => {
5482
3865
  const retVal = (output || [])
5483
3866
  .filter((e) => e != null)
5484
3867
  .map((entry) => {
5485
- if (entry === null) {
5486
- return null;
5487
- }
5488
3868
  return de_ModelScores(entry, context);
5489
3869
  });
5490
3870
  return retVal;
@@ -5493,138 +3873,41 @@ const de_ListOfModelVersionEvaluations = (output, context) => {
5493
3873
  const retVal = (output || [])
5494
3874
  .filter((e) => e != null)
5495
3875
  .map((entry) => {
5496
- if (entry === null) {
5497
- return null;
5498
- }
5499
3876
  return de_ModelVersionEvaluation(entry, context);
5500
3877
  });
5501
3878
  return retVal;
5502
3879
  };
5503
- const de_ListOfModelVersions = (output, context) => {
5504
- const retVal = (output || [])
5505
- .filter((e) => e != null)
5506
- .map((entry) => {
5507
- if (entry === null) {
5508
- return null;
5509
- }
5510
- return de_ModelVersion(entry, context);
5511
- });
5512
- return retVal;
5513
- };
5514
- const de_ListOfRuleResults = (output, context) => {
5515
- const retVal = (output || [])
5516
- .filter((e) => e != null)
5517
- .map((entry) => {
5518
- if (entry === null) {
5519
- return null;
5520
- }
5521
- return de_RuleResult(entry, context);
5522
- });
5523
- return retVal;
5524
- };
5525
- const de_ListOfStrings = (output, context) => {
5526
- const retVal = (output || [])
5527
- .filter((e) => e != null)
5528
- .map((entry) => {
5529
- if (entry === null) {
5530
- return null;
5531
- }
5532
- return __expectString(entry);
5533
- });
5534
- return retVal;
5535
- };
5536
3880
  const de_listOfVariableImpactExplanations = (output, context) => {
5537
3881
  const retVal = (output || [])
5538
3882
  .filter((e) => e != null)
5539
3883
  .map((entry) => {
5540
- if (entry === null) {
5541
- return null;
5542
- }
5543
3884
  return de_VariableImpactExplanation(entry, context);
5544
3885
  });
5545
3886
  return retVal;
5546
3887
  };
5547
- const de_ListTagsForResourceResult = (output, context) => {
5548
- return {
5549
- nextToken: __expectString(output.nextToken),
5550
- tags: output.tags != null ? de_tagList(output.tags, context) : undefined,
5551
- };
5552
- };
5553
3888
  const de_LogOddsMetric = (output, context) => {
5554
- return {
5555
- variableImportance: __limitedParseFloat32(output.variableImportance),
5556
- variableName: __expectString(output.variableName),
5557
- variableType: __expectString(output.variableType),
5558
- };
5559
- };
5560
- const de_MapOfStrings = (output, context) => {
5561
- return Object.entries(output).reduce((acc, [key, value]) => {
5562
- if (value === null) {
5563
- return acc;
5564
- }
5565
- acc[key] = __expectString(value);
5566
- return acc;
5567
- }, {});
3889
+ return take(output, {
3890
+ variableImportance: __limitedParseFloat32,
3891
+ variableName: __expectString,
3892
+ variableType: __expectString,
3893
+ });
5568
3894
  };
5569
3895
  const de_MetricDataPoint = (output, context) => {
5570
- return {
5571
- fpr: __limitedParseFloat32(output.fpr),
5572
- precision: __limitedParseFloat32(output.precision),
5573
- threshold: __limitedParseFloat32(output.threshold),
5574
- tpr: __limitedParseFloat32(output.tpr),
5575
- };
3896
+ return take(output, {
3897
+ fpr: __limitedParseFloat32,
3898
+ precision: __limitedParseFloat32,
3899
+ threshold: __limitedParseFloat32,
3900
+ tpr: __limitedParseFloat32,
3901
+ });
5576
3902
  };
5577
3903
  const de_metricDataPointsList = (output, context) => {
5578
3904
  const retVal = (output || [])
5579
3905
  .filter((e) => e != null)
5580
3906
  .map((entry) => {
5581
- if (entry === null) {
5582
- return null;
5583
- }
5584
3907
  return de_MetricDataPoint(entry, context);
5585
3908
  });
5586
3909
  return retVal;
5587
3910
  };
5588
- const de_Model = (output, context) => {
5589
- return {
5590
- arn: __expectString(output.arn),
5591
- createdTime: __expectString(output.createdTime),
5592
- description: __expectString(output.description),
5593
- eventTypeName: __expectString(output.eventTypeName),
5594
- lastUpdatedTime: __expectString(output.lastUpdatedTime),
5595
- modelId: __expectString(output.modelId),
5596
- modelType: __expectString(output.modelType),
5597
- };
5598
- };
5599
- const de_ModelInputConfiguration = (output, context) => {
5600
- return {
5601
- csvInputTemplate: __expectString(output.csvInputTemplate),
5602
- eventTypeName: __expectString(output.eventTypeName),
5603
- format: __expectString(output.format),
5604
- jsonInputTemplate: __expectString(output.jsonInputTemplate),
5605
- useEventVariables: __expectBoolean(output.useEventVariables),
5606
- };
5607
- };
5608
- const de_modelList = (output, context) => {
5609
- const retVal = (output || [])
5610
- .filter((e) => e != null)
5611
- .map((entry) => {
5612
- if (entry === null) {
5613
- return null;
5614
- }
5615
- return de_Model(entry, context);
5616
- });
5617
- return retVal;
5618
- };
5619
- const de_ModelOutputConfiguration = (output, context) => {
5620
- return {
5621
- csvIndexToVariableMap: output.csvIndexToVariableMap != null
5622
- ? de_CsvIndexToVariableMap(output.csvIndexToVariableMap, context)
5623
- : undefined,
5624
- format: __expectString(output.format),
5625
- jsonKeyToVariableMap: output.jsonKeyToVariableMap != null ? de_JsonKeyToVariableMap(output.jsonKeyToVariableMap, context) : undefined,
5626
- };
5627
- };
5628
3911
  const de_ModelPredictionMap = (output, context) => {
5629
3912
  return Object.entries(output).reduce((acc, [key, value]) => {
5630
3913
  if (value === null) {
@@ -5635,400 +3918,150 @@ const de_ModelPredictionMap = (output, context) => {
5635
3918
  }, {});
5636
3919
  };
5637
3920
  const de_ModelScores = (output, context) => {
5638
- return {
5639
- modelVersion: output.modelVersion != null ? de_ModelVersion(output.modelVersion, context) : undefined,
5640
- scores: output.scores != null ? de_ModelPredictionMap(output.scores, context) : undefined,
5641
- };
5642
- };
5643
- const de_ModelVersion = (output, context) => {
5644
- return {
5645
- arn: __expectString(output.arn),
5646
- modelId: __expectString(output.modelId),
5647
- modelType: __expectString(output.modelType),
5648
- modelVersionNumber: __expectString(output.modelVersionNumber),
5649
- };
3921
+ return take(output, {
3922
+ modelVersion: _json,
3923
+ scores: (_) => de_ModelPredictionMap(_, context),
3924
+ });
5650
3925
  };
5651
3926
  const de_ModelVersionDetail = (output, context) => {
5652
- return {
5653
- arn: __expectString(output.arn),
5654
- createdTime: __expectString(output.createdTime),
5655
- externalEventsDetail: output.externalEventsDetail != null ? de_ExternalEventsDetail(output.externalEventsDetail, context) : undefined,
5656
- ingestedEventsDetail: output.ingestedEventsDetail != null ? de_IngestedEventsDetail(output.ingestedEventsDetail, context) : undefined,
5657
- lastUpdatedTime: __expectString(output.lastUpdatedTime),
5658
- modelId: __expectString(output.modelId),
5659
- modelType: __expectString(output.modelType),
5660
- modelVersionNumber: __expectString(output.modelVersionNumber),
5661
- status: __expectString(output.status),
5662
- trainingDataSchema: output.trainingDataSchema != null ? de_TrainingDataSchema(output.trainingDataSchema, context) : undefined,
5663
- trainingDataSource: __expectString(output.trainingDataSource),
5664
- trainingResult: output.trainingResult != null ? de_TrainingResult(output.trainingResult, context) : undefined,
5665
- trainingResultV2: output.trainingResultV2 != null ? de_TrainingResultV2(output.trainingResultV2, context) : undefined,
5666
- };
3927
+ return take(output, {
3928
+ arn: __expectString,
3929
+ createdTime: __expectString,
3930
+ externalEventsDetail: _json,
3931
+ ingestedEventsDetail: _json,
3932
+ lastUpdatedTime: __expectString,
3933
+ modelId: __expectString,
3934
+ modelType: __expectString,
3935
+ modelVersionNumber: __expectString,
3936
+ status: __expectString,
3937
+ trainingDataSchema: _json,
3938
+ trainingDataSource: __expectString,
3939
+ trainingResult: (_) => de_TrainingResult(_, context),
3940
+ trainingResultV2: (_) => de_TrainingResultV2(_, context),
3941
+ });
5667
3942
  };
5668
3943
  const de_modelVersionDetailList = (output, context) => {
5669
3944
  const retVal = (output || [])
5670
3945
  .filter((e) => e != null)
5671
3946
  .map((entry) => {
5672
- if (entry === null) {
5673
- return null;
5674
- }
5675
3947
  return de_ModelVersionDetail(entry, context);
5676
3948
  });
5677
3949
  return retVal;
5678
3950
  };
5679
3951
  const de_ModelVersionEvaluation = (output, context) => {
5680
- return {
5681
- evaluationScore: __expectString(output.evaluationScore),
5682
- outputVariableName: __expectString(output.outputVariableName),
5683
- predictionExplanations: output.predictionExplanations != null
5684
- ? de_PredictionExplanations(output.predictionExplanations, context)
5685
- : undefined,
5686
- };
5687
- };
5688
- const de_NonEmptyListOfStrings = (output, context) => {
5689
- const retVal = (output || [])
5690
- .filter((e) => e != null)
5691
- .map((entry) => {
5692
- if (entry === null) {
5693
- return null;
5694
- }
5695
- return __expectString(entry);
3952
+ return take(output, {
3953
+ evaluationScore: __expectString,
3954
+ outputVariableName: __expectString,
3955
+ predictionExplanations: (_) => de_PredictionExplanations(_, context),
5696
3956
  });
5697
- return retVal;
5698
3957
  };
5699
3958
  const de_OFIMetricDataPoint = (output, context) => {
5700
- return {
5701
- fpr: __limitedParseFloat32(output.fpr),
5702
- precision: __limitedParseFloat32(output.precision),
5703
- threshold: __limitedParseFloat32(output.threshold),
5704
- tpr: __limitedParseFloat32(output.tpr),
5705
- };
3959
+ return take(output, {
3960
+ fpr: __limitedParseFloat32,
3961
+ precision: __limitedParseFloat32,
3962
+ threshold: __limitedParseFloat32,
3963
+ tpr: __limitedParseFloat32,
3964
+ });
5706
3965
  };
5707
3966
  const de_OFIMetricDataPointsList = (output, context) => {
5708
3967
  const retVal = (output || [])
5709
3968
  .filter((e) => e != null)
5710
3969
  .map((entry) => {
5711
- if (entry === null) {
5712
- return null;
5713
- }
5714
3970
  return de_OFIMetricDataPoint(entry, context);
5715
3971
  });
5716
3972
  return retVal;
5717
3973
  };
5718
3974
  const de_OFIModelPerformance = (output, context) => {
5719
- return {
5720
- auc: __limitedParseFloat32(output.auc),
5721
- uncertaintyRange: output.uncertaintyRange != null ? de_UncertaintyRange(output.uncertaintyRange, context) : undefined,
5722
- };
3975
+ return take(output, {
3976
+ auc: __limitedParseFloat32,
3977
+ uncertaintyRange: (_) => de_UncertaintyRange(_, context),
3978
+ });
5723
3979
  };
5724
3980
  const de_OFITrainingMetricsValue = (output, context) => {
5725
- return {
5726
- metricDataPoints: output.metricDataPoints != null ? de_OFIMetricDataPointsList(output.metricDataPoints, context) : undefined,
5727
- modelPerformance: output.modelPerformance != null ? de_OFIModelPerformance(output.modelPerformance, context) : undefined,
5728
- };
5729
- };
5730
- const de_Outcome = (output, context) => {
5731
- return {
5732
- arn: __expectString(output.arn),
5733
- createdTime: __expectString(output.createdTime),
5734
- description: __expectString(output.description),
5735
- lastUpdatedTime: __expectString(output.lastUpdatedTime),
5736
- name: __expectString(output.name),
5737
- };
5738
- };
5739
- const de_OutcomeList = (output, context) => {
5740
- const retVal = (output || [])
5741
- .filter((e) => e != null)
5742
- .map((entry) => {
5743
- if (entry === null) {
5744
- return null;
5745
- }
5746
- return de_Outcome(entry, context);
3981
+ return take(output, {
3982
+ metricDataPoints: (_) => de_OFIMetricDataPointsList(_, context),
3983
+ modelPerformance: (_) => de_OFIModelPerformance(_, context),
5747
3984
  });
5748
- return retVal;
5749
3985
  };
5750
3986
  const de_PredictionExplanations = (output, context) => {
5751
- return {
5752
- aggregatedVariablesImpactExplanations: output.aggregatedVariablesImpactExplanations != null
5753
- ? de_ListOfAggregatedVariablesImpactExplanations(output.aggregatedVariablesImpactExplanations, context)
5754
- : undefined,
5755
- variableImpactExplanations: output.variableImpactExplanations != null
5756
- ? de_listOfVariableImpactExplanations(output.variableImpactExplanations, context)
5757
- : undefined,
5758
- };
5759
- };
5760
- const de_PutDetectorResult = (output, context) => {
5761
- return {};
5762
- };
5763
- const de_PutEntityTypeResult = (output, context) => {
5764
- return {};
5765
- };
5766
- const de_PutEventTypeResult = (output, context) => {
5767
- return {};
5768
- };
5769
- const de_PutExternalModelResult = (output, context) => {
5770
- return {};
5771
- };
5772
- const de_PutKMSEncryptionKeyResult = (output, context) => {
5773
- return {};
5774
- };
5775
- const de_PutLabelResult = (output, context) => {
5776
- return {};
5777
- };
5778
- const de_PutOutcomeResult = (output, context) => {
5779
- return {};
5780
- };
5781
- const de_ResourceNotFoundException = (output, context) => {
5782
- return {
5783
- message: __expectString(output.message),
5784
- };
5785
- };
5786
- const de_ResourceUnavailableException = (output, context) => {
5787
- return {
5788
- message: __expectString(output.message),
5789
- };
5790
- };
5791
- const de_Rule = (output, context) => {
5792
- return {
5793
- detectorId: __expectString(output.detectorId),
5794
- ruleId: __expectString(output.ruleId),
5795
- ruleVersion: __expectString(output.ruleVersion),
5796
- };
5797
- };
5798
- const de_RuleDetail = (output, context) => {
5799
- return {
5800
- arn: __expectString(output.arn),
5801
- createdTime: __expectString(output.createdTime),
5802
- description: __expectString(output.description),
5803
- detectorId: __expectString(output.detectorId),
5804
- expression: __expectString(output.expression),
5805
- language: __expectString(output.language),
5806
- lastUpdatedTime: __expectString(output.lastUpdatedTime),
5807
- outcomes: output.outcomes != null ? de_NonEmptyListOfStrings(output.outcomes, context) : undefined,
5808
- ruleId: __expectString(output.ruleId),
5809
- ruleVersion: __expectString(output.ruleVersion),
5810
- };
5811
- };
5812
- const de_RuleDetailList = (output, context) => {
5813
- const retVal = (output || [])
5814
- .filter((e) => e != null)
5815
- .map((entry) => {
5816
- if (entry === null) {
5817
- return null;
5818
- }
5819
- return de_RuleDetail(entry, context);
5820
- });
5821
- return retVal;
5822
- };
5823
- const de_RuleList = (output, context) => {
5824
- const retVal = (output || [])
5825
- .filter((e) => e != null)
5826
- .map((entry) => {
5827
- if (entry === null) {
5828
- return null;
5829
- }
5830
- return de_Rule(entry, context);
5831
- });
5832
- return retVal;
5833
- };
5834
- const de_RuleResult = (output, context) => {
5835
- return {
5836
- outcomes: output.outcomes != null ? de_ListOfStrings(output.outcomes, context) : undefined,
5837
- ruleId: __expectString(output.ruleId),
5838
- };
5839
- };
5840
- const de_SendEventResult = (output, context) => {
5841
- return {};
5842
- };
5843
- const de_Tag = (output, context) => {
5844
- return {
5845
- key: __expectString(output.key),
5846
- value: __expectString(output.value),
5847
- };
5848
- };
5849
- const de_tagList = (output, context) => {
5850
- const retVal = (output || [])
5851
- .filter((e) => e != null)
5852
- .map((entry) => {
5853
- if (entry === null) {
5854
- return null;
5855
- }
5856
- return de_Tag(entry, context);
3987
+ return take(output, {
3988
+ aggregatedVariablesImpactExplanations: (_) => de_ListOfAggregatedVariablesImpactExplanations(_, context),
3989
+ variableImpactExplanations: (_) => de_listOfVariableImpactExplanations(_, context),
5857
3990
  });
5858
- return retVal;
5859
- };
5860
- const de_TagResourceResult = (output, context) => {
5861
- return {};
5862
3991
  };
5863
3992
  const de_TFIMetricDataPoint = (output, context) => {
5864
- return {
5865
- fpr: __limitedParseFloat32(output.fpr),
5866
- precision: __limitedParseFloat32(output.precision),
5867
- threshold: __limitedParseFloat32(output.threshold),
5868
- tpr: __limitedParseFloat32(output.tpr),
5869
- };
3993
+ return take(output, {
3994
+ fpr: __limitedParseFloat32,
3995
+ precision: __limitedParseFloat32,
3996
+ threshold: __limitedParseFloat32,
3997
+ tpr: __limitedParseFloat32,
3998
+ });
5870
3999
  };
5871
4000
  const de_TFIMetricDataPointsList = (output, context) => {
5872
4001
  const retVal = (output || [])
5873
4002
  .filter((e) => e != null)
5874
4003
  .map((entry) => {
5875
- if (entry === null) {
5876
- return null;
5877
- }
5878
4004
  return de_TFIMetricDataPoint(entry, context);
5879
4005
  });
5880
4006
  return retVal;
5881
4007
  };
5882
4008
  const de_TFIModelPerformance = (output, context) => {
5883
- return {
5884
- auc: __limitedParseFloat32(output.auc),
5885
- uncertaintyRange: output.uncertaintyRange != null ? de_UncertaintyRange(output.uncertaintyRange, context) : undefined,
5886
- };
4009
+ return take(output, {
4010
+ auc: __limitedParseFloat32,
4011
+ uncertaintyRange: (_) => de_UncertaintyRange(_, context),
4012
+ });
5887
4013
  };
5888
4014
  const de_TFITrainingMetricsValue = (output, context) => {
5889
- return {
5890
- metricDataPoints: output.metricDataPoints != null ? de_TFIMetricDataPointsList(output.metricDataPoints, context) : undefined,
5891
- modelPerformance: output.modelPerformance != null ? de_TFIModelPerformance(output.modelPerformance, context) : undefined,
5892
- };
5893
- };
5894
- const de_ThrottlingException = (output, context) => {
5895
- return {
5896
- message: __expectString(output.message),
5897
- };
5898
- };
5899
- const de_TrainingDataSchema = (output, context) => {
5900
- return {
5901
- labelSchema: output.labelSchema != null ? de_LabelSchema(output.labelSchema, context) : undefined,
5902
- modelVariables: output.modelVariables != null ? de_ListOfStrings(output.modelVariables, context) : undefined,
5903
- };
4015
+ return take(output, {
4016
+ metricDataPoints: (_) => de_TFIMetricDataPointsList(_, context),
4017
+ modelPerformance: (_) => de_TFIModelPerformance(_, context),
4018
+ });
5904
4019
  };
5905
4020
  const de_TrainingMetrics = (output, context) => {
5906
- return {
5907
- auc: __limitedParseFloat32(output.auc),
5908
- metricDataPoints: output.metricDataPoints != null ? de_metricDataPointsList(output.metricDataPoints, context) : undefined,
5909
- };
4021
+ return take(output, {
4022
+ auc: __limitedParseFloat32,
4023
+ metricDataPoints: (_) => de_metricDataPointsList(_, context),
4024
+ });
5910
4025
  };
5911
4026
  const de_TrainingMetricsV2 = (output, context) => {
5912
- return {
5913
- ati: output.ati != null ? de_ATITrainingMetricsValue(output.ati, context) : undefined,
5914
- ofi: output.ofi != null ? de_OFITrainingMetricsValue(output.ofi, context) : undefined,
5915
- tfi: output.tfi != null ? de_TFITrainingMetricsValue(output.tfi, context) : undefined,
5916
- };
4027
+ return take(output, {
4028
+ ati: (_) => de_ATITrainingMetricsValue(_, context),
4029
+ ofi: (_) => de_OFITrainingMetricsValue(_, context),
4030
+ tfi: (_) => de_TFITrainingMetricsValue(_, context),
4031
+ });
5917
4032
  };
5918
4033
  const de_TrainingResult = (output, context) => {
5919
- return {
5920
- dataValidationMetrics: output.dataValidationMetrics != null
5921
- ? de_DataValidationMetrics(output.dataValidationMetrics, context)
5922
- : undefined,
5923
- trainingMetrics: output.trainingMetrics != null ? de_TrainingMetrics(output.trainingMetrics, context) : undefined,
5924
- variableImportanceMetrics: output.variableImportanceMetrics != null
5925
- ? de_VariableImportanceMetrics(output.variableImportanceMetrics, context)
5926
- : undefined,
5927
- };
4034
+ return take(output, {
4035
+ dataValidationMetrics: _json,
4036
+ trainingMetrics: (_) => de_TrainingMetrics(_, context),
4037
+ variableImportanceMetrics: (_) => de_VariableImportanceMetrics(_, context),
4038
+ });
5928
4039
  };
5929
4040
  const de_TrainingResultV2 = (output, context) => {
5930
- return {
5931
- aggregatedVariablesImportanceMetrics: output.aggregatedVariablesImportanceMetrics != null
5932
- ? de_AggregatedVariablesImportanceMetrics(output.aggregatedVariablesImportanceMetrics, context)
5933
- : undefined,
5934
- dataValidationMetrics: output.dataValidationMetrics != null
5935
- ? de_DataValidationMetrics(output.dataValidationMetrics, context)
5936
- : undefined,
5937
- trainingMetricsV2: output.trainingMetricsV2 != null ? de_TrainingMetricsV2(output.trainingMetricsV2, context) : undefined,
5938
- variableImportanceMetrics: output.variableImportanceMetrics != null
5939
- ? de_VariableImportanceMetrics(output.variableImportanceMetrics, context)
5940
- : undefined,
5941
- };
4041
+ return take(output, {
4042
+ aggregatedVariablesImportanceMetrics: (_) => de_AggregatedVariablesImportanceMetrics(_, context),
4043
+ dataValidationMetrics: _json,
4044
+ trainingMetricsV2: (_) => de_TrainingMetricsV2(_, context),
4045
+ variableImportanceMetrics: (_) => de_VariableImportanceMetrics(_, context),
4046
+ });
5942
4047
  };
5943
4048
  const de_UncertaintyRange = (output, context) => {
5944
- return {
5945
- lowerBoundValue: __limitedParseFloat32(output.lowerBoundValue),
5946
- upperBoundValue: __limitedParseFloat32(output.upperBoundValue),
5947
- };
5948
- };
5949
- const de_UntagResourceResult = (output, context) => {
5950
- return {};
5951
- };
5952
- const de_UpdateDetectorVersionMetadataResult = (output, context) => {
5953
- return {};
5954
- };
5955
- const de_UpdateDetectorVersionResult = (output, context) => {
5956
- return {};
5957
- };
5958
- const de_UpdateDetectorVersionStatusResult = (output, context) => {
5959
- return {};
5960
- };
5961
- const de_UpdateEventLabelResult = (output, context) => {
5962
- return {};
5963
- };
5964
- const de_UpdateListResult = (output, context) => {
5965
- return {};
5966
- };
5967
- const de_UpdateModelResult = (output, context) => {
5968
- return {};
5969
- };
5970
- const de_UpdateModelVersionResult = (output, context) => {
5971
- return {
5972
- modelId: __expectString(output.modelId),
5973
- modelType: __expectString(output.modelType),
5974
- modelVersionNumber: __expectString(output.modelVersionNumber),
5975
- status: __expectString(output.status),
5976
- };
5977
- };
5978
- const de_UpdateModelVersionStatusResult = (output, context) => {
5979
- return {};
5980
- };
5981
- const de_UpdateRuleMetadataResult = (output, context) => {
5982
- return {};
5983
- };
5984
- const de_UpdateRuleVersionResult = (output, context) => {
5985
- return {
5986
- rule: output.rule != null ? de_Rule(output.rule, context) : undefined,
5987
- };
5988
- };
5989
- const de_UpdateVariableResult = (output, context) => {
5990
- return {};
5991
- };
5992
- const de_ValidationException = (output, context) => {
5993
- return {
5994
- message: __expectString(output.message),
5995
- };
5996
- };
5997
- const de_Variable = (output, context) => {
5998
- return {
5999
- arn: __expectString(output.arn),
6000
- createdTime: __expectString(output.createdTime),
6001
- dataSource: __expectString(output.dataSource),
6002
- dataType: __expectString(output.dataType),
6003
- defaultValue: __expectString(output.defaultValue),
6004
- description: __expectString(output.description),
6005
- lastUpdatedTime: __expectString(output.lastUpdatedTime),
6006
- name: __expectString(output.name),
6007
- variableType: __expectString(output.variableType),
6008
- };
4049
+ return take(output, {
4050
+ lowerBoundValue: __limitedParseFloat32,
4051
+ upperBoundValue: __limitedParseFloat32,
4052
+ });
6009
4053
  };
6010
4054
  const de_VariableImpactExplanation = (output, context) => {
6011
- return {
6012
- eventVariableName: __expectString(output.eventVariableName),
6013
- logOddsImpact: __limitedParseFloat32(output.logOddsImpact),
6014
- relativeImpact: __expectString(output.relativeImpact),
6015
- };
4055
+ return take(output, {
4056
+ eventVariableName: __expectString,
4057
+ logOddsImpact: __limitedParseFloat32,
4058
+ relativeImpact: __expectString,
4059
+ });
6016
4060
  };
6017
4061
  const de_VariableImportanceMetrics = (output, context) => {
6018
- return {
6019
- logOddsMetrics: output.logOddsMetrics != null ? de_ListOfLogOddsMetrics(output.logOddsMetrics, context) : undefined,
6020
- };
6021
- };
6022
- const de_VariableList = (output, context) => {
6023
- const retVal = (output || [])
6024
- .filter((e) => e != null)
6025
- .map((entry) => {
6026
- if (entry === null) {
6027
- return null;
6028
- }
6029
- return de_Variable(entry, context);
4062
+ return take(output, {
4063
+ logOddsMetrics: (_) => de_ListOfLogOddsMetrics(_, context),
6030
4064
  });
6031
- return retVal;
6032
4065
  };
6033
4066
  const deserializeMetadata = (output) => ({
6034
4067
  httpStatusCode: output.statusCode,
@@ -6043,6 +4076,7 @@ const collectBody = (streamBody = new Uint8Array(), context) => {
6043
4076
  return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
6044
4077
  };
6045
4078
  const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
4079
+ const throwDefaultError = withBaseException(__BaseException);
6046
4080
  const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
6047
4081
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
6048
4082
  const contents = {