@aws-sdk/client-cloudwatch 3.476.0 → 3.478.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist-cjs/pagination/DescribeAlarmHistoryPaginator.js +2 -24
- package/dist-cjs/pagination/DescribeAlarmsPaginator.js +2 -24
- package/dist-cjs/pagination/DescribeAnomalyDetectorsPaginator.js +2 -24
- package/dist-cjs/pagination/DescribeInsightRulesPaginator.js +2 -24
- package/dist-cjs/pagination/GetMetricDataPaginator.js +2 -24
- package/dist-cjs/pagination/ListDashboardsPaginator.js +2 -23
- package/dist-cjs/pagination/ListManagedInsightRulesPaginator.js +2 -24
- package/dist-cjs/pagination/ListMetricStreamsPaginator.js +2 -24
- package/dist-cjs/pagination/ListMetricsPaginator.js +2 -23
- package/dist-cjs/protocols/Aws_query.js +1242 -1039
- package/dist-es/pagination/DescribeAlarmHistoryPaginator.js +2 -23
- package/dist-es/pagination/DescribeAlarmsPaginator.js +2 -23
- package/dist-es/pagination/DescribeAnomalyDetectorsPaginator.js +2 -23
- package/dist-es/pagination/DescribeInsightRulesPaginator.js +2 -23
- package/dist-es/pagination/GetMetricDataPaginator.js +2 -23
- package/dist-es/pagination/ListDashboardsPaginator.js +2 -22
- package/dist-es/pagination/ListManagedInsightRulesPaginator.js +2 -23
- package/dist-es/pagination/ListMetricStreamsPaginator.js +2 -23
- package/dist-es/pagination/ListMetricsPaginator.js +2 -22
- package/dist-es/protocols/Aws_query.js +1242 -1039
- package/dist-types/pagination/DescribeAlarmHistoryPaginator.d.ts +1 -1
- package/dist-types/pagination/DescribeAlarmsPaginator.d.ts +1 -1
- package/dist-types/pagination/DescribeAnomalyDetectorsPaginator.d.ts +1 -1
- package/dist-types/pagination/DescribeInsightRulesPaginator.d.ts +1 -1
- package/dist-types/pagination/GetMetricDataPaginator.d.ts +1 -1
- package/dist-types/pagination/ListDashboardsPaginator.d.ts +1 -1
- package/dist-types/pagination/ListManagedInsightRulesPaginator.d.ts +1 -1
- package/dist-types/pagination/ListMetricStreamsPaginator.d.ts +1 -1
- package/dist-types/pagination/ListMetricsPaginator.d.ts +1 -1
- package/dist-types/ts3.4/pagination/DescribeAlarmHistoryPaginator.d.ts +3 -3
- package/dist-types/ts3.4/pagination/DescribeAlarmsPaginator.d.ts +3 -3
- package/dist-types/ts3.4/pagination/DescribeAnomalyDetectorsPaginator.d.ts +3 -3
- package/dist-types/ts3.4/pagination/DescribeInsightRulesPaginator.d.ts +3 -3
- package/dist-types/ts3.4/pagination/GetMetricDataPaginator.d.ts +3 -3
- package/dist-types/ts3.4/pagination/ListDashboardsPaginator.d.ts +3 -3
- package/dist-types/ts3.4/pagination/ListManagedInsightRulesPaginator.d.ts +3 -3
- package/dist-types/ts3.4/pagination/ListMetricStreamsPaginator.d.ts +3 -3
- package/dist-types/ts3.4/pagination/ListMetricsPaginator.d.ts +3 -3
- package/package.json +7 -6
|
@@ -8,8 +8,8 @@ export const se_DeleteAlarmsCommand = async (input, context) => {
|
|
|
8
8
|
let body;
|
|
9
9
|
body = buildFormUrlencodedString({
|
|
10
10
|
...se_DeleteAlarmsInput(input, context),
|
|
11
|
-
|
|
12
|
-
|
|
11
|
+
[_A]: _DA,
|
|
12
|
+
[_V]: _,
|
|
13
13
|
});
|
|
14
14
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
15
15
|
};
|
|
@@ -18,8 +18,8 @@ export const se_DeleteAnomalyDetectorCommand = async (input, context) => {
|
|
|
18
18
|
let body;
|
|
19
19
|
body = buildFormUrlencodedString({
|
|
20
20
|
...se_DeleteAnomalyDetectorInput(input, context),
|
|
21
|
-
|
|
22
|
-
|
|
21
|
+
[_A]: _DAD,
|
|
22
|
+
[_V]: _,
|
|
23
23
|
});
|
|
24
24
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
25
25
|
};
|
|
@@ -28,8 +28,8 @@ export const se_DeleteDashboardsCommand = async (input, context) => {
|
|
|
28
28
|
let body;
|
|
29
29
|
body = buildFormUrlencodedString({
|
|
30
30
|
...se_DeleteDashboardsInput(input, context),
|
|
31
|
-
|
|
32
|
-
|
|
31
|
+
[_A]: _DD,
|
|
32
|
+
[_V]: _,
|
|
33
33
|
});
|
|
34
34
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
35
35
|
};
|
|
@@ -38,8 +38,8 @@ export const se_DeleteInsightRulesCommand = async (input, context) => {
|
|
|
38
38
|
let body;
|
|
39
39
|
body = buildFormUrlencodedString({
|
|
40
40
|
...se_DeleteInsightRulesInput(input, context),
|
|
41
|
-
|
|
42
|
-
|
|
41
|
+
[_A]: _DIR,
|
|
42
|
+
[_V]: _,
|
|
43
43
|
});
|
|
44
44
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
45
45
|
};
|
|
@@ -48,8 +48,8 @@ export const se_DeleteMetricStreamCommand = async (input, context) => {
|
|
|
48
48
|
let body;
|
|
49
49
|
body = buildFormUrlencodedString({
|
|
50
50
|
...se_DeleteMetricStreamInput(input, context),
|
|
51
|
-
|
|
52
|
-
|
|
51
|
+
[_A]: _DMS,
|
|
52
|
+
[_V]: _,
|
|
53
53
|
});
|
|
54
54
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
55
55
|
};
|
|
@@ -58,8 +58,8 @@ export const se_DescribeAlarmHistoryCommand = async (input, context) => {
|
|
|
58
58
|
let body;
|
|
59
59
|
body = buildFormUrlencodedString({
|
|
60
60
|
...se_DescribeAlarmHistoryInput(input, context),
|
|
61
|
-
|
|
62
|
-
|
|
61
|
+
[_A]: _DAH,
|
|
62
|
+
[_V]: _,
|
|
63
63
|
});
|
|
64
64
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
65
65
|
};
|
|
@@ -68,8 +68,8 @@ export const se_DescribeAlarmsCommand = async (input, context) => {
|
|
|
68
68
|
let body;
|
|
69
69
|
body = buildFormUrlencodedString({
|
|
70
70
|
...se_DescribeAlarmsInput(input, context),
|
|
71
|
-
|
|
72
|
-
|
|
71
|
+
[_A]: _DAe,
|
|
72
|
+
[_V]: _,
|
|
73
73
|
});
|
|
74
74
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
75
75
|
};
|
|
@@ -78,8 +78,8 @@ export const se_DescribeAlarmsForMetricCommand = async (input, context) => {
|
|
|
78
78
|
let body;
|
|
79
79
|
body = buildFormUrlencodedString({
|
|
80
80
|
...se_DescribeAlarmsForMetricInput(input, context),
|
|
81
|
-
|
|
82
|
-
|
|
81
|
+
[_A]: _DAFM,
|
|
82
|
+
[_V]: _,
|
|
83
83
|
});
|
|
84
84
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
85
85
|
};
|
|
@@ -88,8 +88,8 @@ export const se_DescribeAnomalyDetectorsCommand = async (input, context) => {
|
|
|
88
88
|
let body;
|
|
89
89
|
body = buildFormUrlencodedString({
|
|
90
90
|
...se_DescribeAnomalyDetectorsInput(input, context),
|
|
91
|
-
|
|
92
|
-
|
|
91
|
+
[_A]: _DADe,
|
|
92
|
+
[_V]: _,
|
|
93
93
|
});
|
|
94
94
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
95
95
|
};
|
|
@@ -98,8 +98,8 @@ export const se_DescribeInsightRulesCommand = async (input, context) => {
|
|
|
98
98
|
let body;
|
|
99
99
|
body = buildFormUrlencodedString({
|
|
100
100
|
...se_DescribeInsightRulesInput(input, context),
|
|
101
|
-
|
|
102
|
-
|
|
101
|
+
[_A]: _DIRe,
|
|
102
|
+
[_V]: _,
|
|
103
103
|
});
|
|
104
104
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
105
105
|
};
|
|
@@ -108,8 +108,8 @@ export const se_DisableAlarmActionsCommand = async (input, context) => {
|
|
|
108
108
|
let body;
|
|
109
109
|
body = buildFormUrlencodedString({
|
|
110
110
|
...se_DisableAlarmActionsInput(input, context),
|
|
111
|
-
|
|
112
|
-
|
|
111
|
+
[_A]: _DAA,
|
|
112
|
+
[_V]: _,
|
|
113
113
|
});
|
|
114
114
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
115
115
|
};
|
|
@@ -118,8 +118,8 @@ export const se_DisableInsightRulesCommand = async (input, context) => {
|
|
|
118
118
|
let body;
|
|
119
119
|
body = buildFormUrlencodedString({
|
|
120
120
|
...se_DisableInsightRulesInput(input, context),
|
|
121
|
-
|
|
122
|
-
|
|
121
|
+
[_A]: _DIRi,
|
|
122
|
+
[_V]: _,
|
|
123
123
|
});
|
|
124
124
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
125
125
|
};
|
|
@@ -128,8 +128,8 @@ export const se_EnableAlarmActionsCommand = async (input, context) => {
|
|
|
128
128
|
let body;
|
|
129
129
|
body = buildFormUrlencodedString({
|
|
130
130
|
...se_EnableAlarmActionsInput(input, context),
|
|
131
|
-
|
|
132
|
-
|
|
131
|
+
[_A]: _EAA,
|
|
132
|
+
[_V]: _,
|
|
133
133
|
});
|
|
134
134
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
135
135
|
};
|
|
@@ -138,8 +138,8 @@ export const se_EnableInsightRulesCommand = async (input, context) => {
|
|
|
138
138
|
let body;
|
|
139
139
|
body = buildFormUrlencodedString({
|
|
140
140
|
...se_EnableInsightRulesInput(input, context),
|
|
141
|
-
|
|
142
|
-
|
|
141
|
+
[_A]: _EIR,
|
|
142
|
+
[_V]: _,
|
|
143
143
|
});
|
|
144
144
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
145
145
|
};
|
|
@@ -148,8 +148,8 @@ export const se_GetDashboardCommand = async (input, context) => {
|
|
|
148
148
|
let body;
|
|
149
149
|
body = buildFormUrlencodedString({
|
|
150
150
|
...se_GetDashboardInput(input, context),
|
|
151
|
-
|
|
152
|
-
|
|
151
|
+
[_A]: _GD,
|
|
152
|
+
[_V]: _,
|
|
153
153
|
});
|
|
154
154
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
155
155
|
};
|
|
@@ -158,8 +158,8 @@ export const se_GetInsightRuleReportCommand = async (input, context) => {
|
|
|
158
158
|
let body;
|
|
159
159
|
body = buildFormUrlencodedString({
|
|
160
160
|
...se_GetInsightRuleReportInput(input, context),
|
|
161
|
-
|
|
162
|
-
|
|
161
|
+
[_A]: _GIRR,
|
|
162
|
+
[_V]: _,
|
|
163
163
|
});
|
|
164
164
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
165
165
|
};
|
|
@@ -168,8 +168,8 @@ export const se_GetMetricDataCommand = async (input, context) => {
|
|
|
168
168
|
let body;
|
|
169
169
|
body = buildFormUrlencodedString({
|
|
170
170
|
...se_GetMetricDataInput(input, context),
|
|
171
|
-
|
|
172
|
-
|
|
171
|
+
[_A]: _GMD,
|
|
172
|
+
[_V]: _,
|
|
173
173
|
});
|
|
174
174
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
175
175
|
};
|
|
@@ -178,8 +178,8 @@ export const se_GetMetricStatisticsCommand = async (input, context) => {
|
|
|
178
178
|
let body;
|
|
179
179
|
body = buildFormUrlencodedString({
|
|
180
180
|
...se_GetMetricStatisticsInput(input, context),
|
|
181
|
-
|
|
182
|
-
|
|
181
|
+
[_A]: _GMS,
|
|
182
|
+
[_V]: _,
|
|
183
183
|
});
|
|
184
184
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
185
185
|
};
|
|
@@ -188,8 +188,8 @@ export const se_GetMetricStreamCommand = async (input, context) => {
|
|
|
188
188
|
let body;
|
|
189
189
|
body = buildFormUrlencodedString({
|
|
190
190
|
...se_GetMetricStreamInput(input, context),
|
|
191
|
-
|
|
192
|
-
|
|
191
|
+
[_A]: _GMSe,
|
|
192
|
+
[_V]: _,
|
|
193
193
|
});
|
|
194
194
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
195
195
|
};
|
|
@@ -198,8 +198,8 @@ export const se_GetMetricWidgetImageCommand = async (input, context) => {
|
|
|
198
198
|
let body;
|
|
199
199
|
body = buildFormUrlencodedString({
|
|
200
200
|
...se_GetMetricWidgetImageInput(input, context),
|
|
201
|
-
|
|
202
|
-
|
|
201
|
+
[_A]: _GMWI,
|
|
202
|
+
[_V]: _,
|
|
203
203
|
});
|
|
204
204
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
205
205
|
};
|
|
@@ -208,8 +208,8 @@ export const se_ListDashboardsCommand = async (input, context) => {
|
|
|
208
208
|
let body;
|
|
209
209
|
body = buildFormUrlencodedString({
|
|
210
210
|
...se_ListDashboardsInput(input, context),
|
|
211
|
-
|
|
212
|
-
|
|
211
|
+
[_A]: _LD,
|
|
212
|
+
[_V]: _,
|
|
213
213
|
});
|
|
214
214
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
215
215
|
};
|
|
@@ -218,8 +218,8 @@ export const se_ListManagedInsightRulesCommand = async (input, context) => {
|
|
|
218
218
|
let body;
|
|
219
219
|
body = buildFormUrlencodedString({
|
|
220
220
|
...se_ListManagedInsightRulesInput(input, context),
|
|
221
|
-
|
|
222
|
-
|
|
221
|
+
[_A]: _LMIR,
|
|
222
|
+
[_V]: _,
|
|
223
223
|
});
|
|
224
224
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
225
225
|
};
|
|
@@ -228,8 +228,8 @@ export const se_ListMetricsCommand = async (input, context) => {
|
|
|
228
228
|
let body;
|
|
229
229
|
body = buildFormUrlencodedString({
|
|
230
230
|
...se_ListMetricsInput(input, context),
|
|
231
|
-
|
|
232
|
-
|
|
231
|
+
[_A]: _LM,
|
|
232
|
+
[_V]: _,
|
|
233
233
|
});
|
|
234
234
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
235
235
|
};
|
|
@@ -238,8 +238,8 @@ export const se_ListMetricStreamsCommand = async (input, context) => {
|
|
|
238
238
|
let body;
|
|
239
239
|
body = buildFormUrlencodedString({
|
|
240
240
|
...se_ListMetricStreamsInput(input, context),
|
|
241
|
-
|
|
242
|
-
|
|
241
|
+
[_A]: _LMS,
|
|
242
|
+
[_V]: _,
|
|
243
243
|
});
|
|
244
244
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
245
245
|
};
|
|
@@ -248,8 +248,8 @@ export const se_ListTagsForResourceCommand = async (input, context) => {
|
|
|
248
248
|
let body;
|
|
249
249
|
body = buildFormUrlencodedString({
|
|
250
250
|
...se_ListTagsForResourceInput(input, context),
|
|
251
|
-
|
|
252
|
-
|
|
251
|
+
[_A]: _LTFR,
|
|
252
|
+
[_V]: _,
|
|
253
253
|
});
|
|
254
254
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
255
255
|
};
|
|
@@ -258,8 +258,8 @@ export const se_PutAnomalyDetectorCommand = async (input, context) => {
|
|
|
258
258
|
let body;
|
|
259
259
|
body = buildFormUrlencodedString({
|
|
260
260
|
...se_PutAnomalyDetectorInput(input, context),
|
|
261
|
-
|
|
262
|
-
|
|
261
|
+
[_A]: _PAD,
|
|
262
|
+
[_V]: _,
|
|
263
263
|
});
|
|
264
264
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
265
265
|
};
|
|
@@ -268,8 +268,8 @@ export const se_PutCompositeAlarmCommand = async (input, context) => {
|
|
|
268
268
|
let body;
|
|
269
269
|
body = buildFormUrlencodedString({
|
|
270
270
|
...se_PutCompositeAlarmInput(input, context),
|
|
271
|
-
|
|
272
|
-
|
|
271
|
+
[_A]: _PCA,
|
|
272
|
+
[_V]: _,
|
|
273
273
|
});
|
|
274
274
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
275
275
|
};
|
|
@@ -278,8 +278,8 @@ export const se_PutDashboardCommand = async (input, context) => {
|
|
|
278
278
|
let body;
|
|
279
279
|
body = buildFormUrlencodedString({
|
|
280
280
|
...se_PutDashboardInput(input, context),
|
|
281
|
-
|
|
282
|
-
|
|
281
|
+
[_A]: _PD,
|
|
282
|
+
[_V]: _,
|
|
283
283
|
});
|
|
284
284
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
285
285
|
};
|
|
@@ -288,8 +288,8 @@ export const se_PutInsightRuleCommand = async (input, context) => {
|
|
|
288
288
|
let body;
|
|
289
289
|
body = buildFormUrlencodedString({
|
|
290
290
|
...se_PutInsightRuleInput(input, context),
|
|
291
|
-
|
|
292
|
-
|
|
291
|
+
[_A]: _PIR,
|
|
292
|
+
[_V]: _,
|
|
293
293
|
});
|
|
294
294
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
295
295
|
};
|
|
@@ -298,8 +298,8 @@ export const se_PutManagedInsightRulesCommand = async (input, context) => {
|
|
|
298
298
|
let body;
|
|
299
299
|
body = buildFormUrlencodedString({
|
|
300
300
|
...se_PutManagedInsightRulesInput(input, context),
|
|
301
|
-
|
|
302
|
-
|
|
301
|
+
[_A]: _PMIR,
|
|
302
|
+
[_V]: _,
|
|
303
303
|
});
|
|
304
304
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
305
305
|
};
|
|
@@ -308,8 +308,8 @@ export const se_PutMetricAlarmCommand = async (input, context) => {
|
|
|
308
308
|
let body;
|
|
309
309
|
body = buildFormUrlencodedString({
|
|
310
310
|
...se_PutMetricAlarmInput(input, context),
|
|
311
|
-
|
|
312
|
-
|
|
311
|
+
[_A]: _PMA,
|
|
312
|
+
[_V]: _,
|
|
313
313
|
});
|
|
314
314
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
315
315
|
};
|
|
@@ -318,8 +318,8 @@ export const se_PutMetricDataCommand = async (input, context) => {
|
|
|
318
318
|
let body;
|
|
319
319
|
body = buildFormUrlencodedString({
|
|
320
320
|
...se_PutMetricDataInput(input, context),
|
|
321
|
-
|
|
322
|
-
|
|
321
|
+
[_A]: _PMD,
|
|
322
|
+
[_V]: _,
|
|
323
323
|
});
|
|
324
324
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
325
325
|
};
|
|
@@ -328,8 +328,8 @@ export const se_PutMetricStreamCommand = async (input, context) => {
|
|
|
328
328
|
let body;
|
|
329
329
|
body = buildFormUrlencodedString({
|
|
330
330
|
...se_PutMetricStreamInput(input, context),
|
|
331
|
-
|
|
332
|
-
|
|
331
|
+
[_A]: _PMS,
|
|
332
|
+
[_V]: _,
|
|
333
333
|
});
|
|
334
334
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
335
335
|
};
|
|
@@ -338,8 +338,8 @@ export const se_SetAlarmStateCommand = async (input, context) => {
|
|
|
338
338
|
let body;
|
|
339
339
|
body = buildFormUrlencodedString({
|
|
340
340
|
...se_SetAlarmStateInput(input, context),
|
|
341
|
-
|
|
342
|
-
|
|
341
|
+
[_A]: _SAS,
|
|
342
|
+
[_V]: _,
|
|
343
343
|
});
|
|
344
344
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
345
345
|
};
|
|
@@ -348,8 +348,8 @@ export const se_StartMetricStreamsCommand = async (input, context) => {
|
|
|
348
348
|
let body;
|
|
349
349
|
body = buildFormUrlencodedString({
|
|
350
350
|
...se_StartMetricStreamsInput(input, context),
|
|
351
|
-
|
|
352
|
-
|
|
351
|
+
[_A]: _SMS,
|
|
352
|
+
[_V]: _,
|
|
353
353
|
});
|
|
354
354
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
355
355
|
};
|
|
@@ -358,8 +358,8 @@ export const se_StopMetricStreamsCommand = async (input, context) => {
|
|
|
358
358
|
let body;
|
|
359
359
|
body = buildFormUrlencodedString({
|
|
360
360
|
...se_StopMetricStreamsInput(input, context),
|
|
361
|
-
|
|
362
|
-
|
|
361
|
+
[_A]: _SMSt,
|
|
362
|
+
[_V]: _,
|
|
363
363
|
});
|
|
364
364
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
365
365
|
};
|
|
@@ -368,8 +368,8 @@ export const se_TagResourceCommand = async (input, context) => {
|
|
|
368
368
|
let body;
|
|
369
369
|
body = buildFormUrlencodedString({
|
|
370
370
|
...se_TagResourceInput(input, context),
|
|
371
|
-
|
|
372
|
-
|
|
371
|
+
[_A]: _TR,
|
|
372
|
+
[_V]: _,
|
|
373
373
|
});
|
|
374
374
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
375
375
|
};
|
|
@@ -378,8 +378,8 @@ export const se_UntagResourceCommand = async (input, context) => {
|
|
|
378
378
|
let body;
|
|
379
379
|
body = buildFormUrlencodedString({
|
|
380
380
|
...se_UntagResourceInput(input, context),
|
|
381
|
-
|
|
382
|
-
|
|
381
|
+
[_A]: _UR,
|
|
382
|
+
[_V]: _,
|
|
383
383
|
});
|
|
384
384
|
return buildHttpRpcRequest(context, headers, "/", undefined, body);
|
|
385
385
|
};
|
|
@@ -1880,9 +1880,9 @@ const se_AlarmTypes = (input, context) => {
|
|
|
1880
1880
|
};
|
|
1881
1881
|
const se_AnomalyDetectorConfiguration = (input, context) => {
|
|
1882
1882
|
const entries = {};
|
|
1883
|
-
if (input
|
|
1884
|
-
const memberEntries = se_AnomalyDetectorExcludedTimeRanges(input
|
|
1885
|
-
if (input
|
|
1883
|
+
if (input[_ETR] != null) {
|
|
1884
|
+
const memberEntries = se_AnomalyDetectorExcludedTimeRanges(input[_ETR], context);
|
|
1885
|
+
if (input[_ETR]?.length === 0) {
|
|
1886
1886
|
entries.ExcludedTimeRanges = [];
|
|
1887
1887
|
}
|
|
1888
1888
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -1890,8 +1890,8 @@ const se_AnomalyDetectorConfiguration = (input, context) => {
|
|
|
1890
1890
|
entries[loc] = value;
|
|
1891
1891
|
});
|
|
1892
1892
|
}
|
|
1893
|
-
if (input
|
|
1894
|
-
entries[
|
|
1893
|
+
if (input[_MT] != null) {
|
|
1894
|
+
entries[_MT] = input[_MT];
|
|
1895
1895
|
}
|
|
1896
1896
|
return entries;
|
|
1897
1897
|
};
|
|
@@ -1948,9 +1948,9 @@ const se_DashboardNames = (input, context) => {
|
|
|
1948
1948
|
};
|
|
1949
1949
|
const se_DeleteAlarmsInput = (input, context) => {
|
|
1950
1950
|
const entries = {};
|
|
1951
|
-
if (input
|
|
1952
|
-
const memberEntries = se_AlarmNames(input
|
|
1953
|
-
if (input
|
|
1951
|
+
if (input[_AN] != null) {
|
|
1952
|
+
const memberEntries = se_AlarmNames(input[_AN], context);
|
|
1953
|
+
if (input[_AN]?.length === 0) {
|
|
1954
1954
|
entries.AlarmNames = [];
|
|
1955
1955
|
}
|
|
1956
1956
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -1962,15 +1962,15 @@ const se_DeleteAlarmsInput = (input, context) => {
|
|
|
1962
1962
|
};
|
|
1963
1963
|
const se_DeleteAnomalyDetectorInput = (input, context) => {
|
|
1964
1964
|
const entries = {};
|
|
1965
|
-
if (input
|
|
1966
|
-
entries[
|
|
1965
|
+
if (input[_N] != null) {
|
|
1966
|
+
entries[_N] = input[_N];
|
|
1967
1967
|
}
|
|
1968
|
-
if (input
|
|
1969
|
-
entries[
|
|
1968
|
+
if (input[_MN] != null) {
|
|
1969
|
+
entries[_MN] = input[_MN];
|
|
1970
1970
|
}
|
|
1971
|
-
if (input
|
|
1972
|
-
const memberEntries = se_Dimensions(input
|
|
1973
|
-
if (input
|
|
1971
|
+
if (input[_D] != null) {
|
|
1972
|
+
const memberEntries = se_Dimensions(input[_D], context);
|
|
1973
|
+
if (input[_D]?.length === 0) {
|
|
1974
1974
|
entries.Dimensions = [];
|
|
1975
1975
|
}
|
|
1976
1976
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -1978,18 +1978,18 @@ const se_DeleteAnomalyDetectorInput = (input, context) => {
|
|
|
1978
1978
|
entries[loc] = value;
|
|
1979
1979
|
});
|
|
1980
1980
|
}
|
|
1981
|
-
if (input
|
|
1982
|
-
entries[
|
|
1981
|
+
if (input[_S] != null) {
|
|
1982
|
+
entries[_S] = input[_S];
|
|
1983
1983
|
}
|
|
1984
|
-
if (input
|
|
1985
|
-
const memberEntries = se_SingleMetricAnomalyDetector(input
|
|
1984
|
+
if (input[_SMAD] != null) {
|
|
1985
|
+
const memberEntries = se_SingleMetricAnomalyDetector(input[_SMAD], context);
|
|
1986
1986
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
1987
1987
|
const loc = `SingleMetricAnomalyDetector.${key}`;
|
|
1988
1988
|
entries[loc] = value;
|
|
1989
1989
|
});
|
|
1990
1990
|
}
|
|
1991
|
-
if (input
|
|
1992
|
-
const memberEntries = se_MetricMathAnomalyDetector(input
|
|
1991
|
+
if (input[_MMAD] != null) {
|
|
1992
|
+
const memberEntries = se_MetricMathAnomalyDetector(input[_MMAD], context);
|
|
1993
1993
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
1994
1994
|
const loc = `MetricMathAnomalyDetector.${key}`;
|
|
1995
1995
|
entries[loc] = value;
|
|
@@ -1999,9 +1999,9 @@ const se_DeleteAnomalyDetectorInput = (input, context) => {
|
|
|
1999
1999
|
};
|
|
2000
2000
|
const se_DeleteDashboardsInput = (input, context) => {
|
|
2001
2001
|
const entries = {};
|
|
2002
|
-
if (input
|
|
2003
|
-
const memberEntries = se_DashboardNames(input
|
|
2004
|
-
if (input
|
|
2002
|
+
if (input[_DN] != null) {
|
|
2003
|
+
const memberEntries = se_DashboardNames(input[_DN], context);
|
|
2004
|
+
if (input[_DN]?.length === 0) {
|
|
2005
2005
|
entries.DashboardNames = [];
|
|
2006
2006
|
}
|
|
2007
2007
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2013,9 +2013,9 @@ const se_DeleteDashboardsInput = (input, context) => {
|
|
|
2013
2013
|
};
|
|
2014
2014
|
const se_DeleteInsightRulesInput = (input, context) => {
|
|
2015
2015
|
const entries = {};
|
|
2016
|
-
if (input
|
|
2017
|
-
const memberEntries = se_InsightRuleNames(input
|
|
2018
|
-
if (input
|
|
2016
|
+
if (input[_RN] != null) {
|
|
2017
|
+
const memberEntries = se_InsightRuleNames(input[_RN], context);
|
|
2018
|
+
if (input[_RN]?.length === 0) {
|
|
2019
2019
|
entries.RuleNames = [];
|
|
2020
2020
|
}
|
|
2021
2021
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2027,19 +2027,19 @@ const se_DeleteInsightRulesInput = (input, context) => {
|
|
|
2027
2027
|
};
|
|
2028
2028
|
const se_DeleteMetricStreamInput = (input, context) => {
|
|
2029
2029
|
const entries = {};
|
|
2030
|
-
if (input
|
|
2031
|
-
entries[
|
|
2030
|
+
if (input[_Na] != null) {
|
|
2031
|
+
entries[_Na] = input[_Na];
|
|
2032
2032
|
}
|
|
2033
2033
|
return entries;
|
|
2034
2034
|
};
|
|
2035
2035
|
const se_DescribeAlarmHistoryInput = (input, context) => {
|
|
2036
2036
|
const entries = {};
|
|
2037
|
-
if (input
|
|
2038
|
-
entries[
|
|
2037
|
+
if (input[_ANl] != null) {
|
|
2038
|
+
entries[_ANl] = input[_ANl];
|
|
2039
2039
|
}
|
|
2040
|
-
if (input
|
|
2041
|
-
const memberEntries = se_AlarmTypes(input
|
|
2042
|
-
if (input
|
|
2040
|
+
if (input[_AT] != null) {
|
|
2041
|
+
const memberEntries = se_AlarmTypes(input[_AT], context);
|
|
2042
|
+
if (input[_AT]?.length === 0) {
|
|
2043
2043
|
entries.AlarmTypes = [];
|
|
2044
2044
|
}
|
|
2045
2045
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2047,43 +2047,43 @@ const se_DescribeAlarmHistoryInput = (input, context) => {
|
|
|
2047
2047
|
entries[loc] = value;
|
|
2048
2048
|
});
|
|
2049
2049
|
}
|
|
2050
|
-
if (input
|
|
2051
|
-
entries[
|
|
2050
|
+
if (input[_HIT] != null) {
|
|
2051
|
+
entries[_HIT] = input[_HIT];
|
|
2052
2052
|
}
|
|
2053
|
-
if (input
|
|
2054
|
-
entries[
|
|
2053
|
+
if (input[_SD] != null) {
|
|
2054
|
+
entries[_SD] = input[_SD].toISOString().split(".")[0] + "Z";
|
|
2055
2055
|
}
|
|
2056
|
-
if (input
|
|
2057
|
-
entries[
|
|
2056
|
+
if (input[_ED] != null) {
|
|
2057
|
+
entries[_ED] = input[_ED].toISOString().split(".")[0] + "Z";
|
|
2058
2058
|
}
|
|
2059
|
-
if (input
|
|
2060
|
-
entries[
|
|
2059
|
+
if (input[_MR] != null) {
|
|
2060
|
+
entries[_MR] = input[_MR];
|
|
2061
2061
|
}
|
|
2062
|
-
if (input
|
|
2063
|
-
entries[
|
|
2062
|
+
if (input[_NT] != null) {
|
|
2063
|
+
entries[_NT] = input[_NT];
|
|
2064
2064
|
}
|
|
2065
|
-
if (input
|
|
2066
|
-
entries[
|
|
2065
|
+
if (input[_SB] != null) {
|
|
2066
|
+
entries[_SB] = input[_SB];
|
|
2067
2067
|
}
|
|
2068
2068
|
return entries;
|
|
2069
2069
|
};
|
|
2070
2070
|
const se_DescribeAlarmsForMetricInput = (input, context) => {
|
|
2071
2071
|
const entries = {};
|
|
2072
|
-
if (input
|
|
2073
|
-
entries[
|
|
2072
|
+
if (input[_MN] != null) {
|
|
2073
|
+
entries[_MN] = input[_MN];
|
|
2074
2074
|
}
|
|
2075
|
-
if (input
|
|
2076
|
-
entries[
|
|
2075
|
+
if (input[_N] != null) {
|
|
2076
|
+
entries[_N] = input[_N];
|
|
2077
2077
|
}
|
|
2078
|
-
if (input
|
|
2079
|
-
entries[
|
|
2078
|
+
if (input[_St] != null) {
|
|
2079
|
+
entries[_St] = input[_St];
|
|
2080
2080
|
}
|
|
2081
|
-
if (input
|
|
2082
|
-
entries[
|
|
2081
|
+
if (input[_ES] != null) {
|
|
2082
|
+
entries[_ES] = input[_ES];
|
|
2083
2083
|
}
|
|
2084
|
-
if (input
|
|
2085
|
-
const memberEntries = se_Dimensions(input
|
|
2086
|
-
if (input
|
|
2084
|
+
if (input[_D] != null) {
|
|
2085
|
+
const memberEntries = se_Dimensions(input[_D], context);
|
|
2086
|
+
if (input[_D]?.length === 0) {
|
|
2087
2087
|
entries.Dimensions = [];
|
|
2088
2088
|
}
|
|
2089
2089
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2091,19 +2091,19 @@ const se_DescribeAlarmsForMetricInput = (input, context) => {
|
|
|
2091
2091
|
entries[loc] = value;
|
|
2092
2092
|
});
|
|
2093
2093
|
}
|
|
2094
|
-
if (input
|
|
2095
|
-
entries[
|
|
2094
|
+
if (input[_P] != null) {
|
|
2095
|
+
entries[_P] = input[_P];
|
|
2096
2096
|
}
|
|
2097
|
-
if (input
|
|
2098
|
-
entries[
|
|
2097
|
+
if (input[_U] != null) {
|
|
2098
|
+
entries[_U] = input[_U];
|
|
2099
2099
|
}
|
|
2100
2100
|
return entries;
|
|
2101
2101
|
};
|
|
2102
2102
|
const se_DescribeAlarmsInput = (input, context) => {
|
|
2103
2103
|
const entries = {};
|
|
2104
|
-
if (input
|
|
2105
|
-
const memberEntries = se_AlarmNames(input
|
|
2106
|
-
if (input
|
|
2104
|
+
if (input[_AN] != null) {
|
|
2105
|
+
const memberEntries = se_AlarmNames(input[_AN], context);
|
|
2106
|
+
if (input[_AN]?.length === 0) {
|
|
2107
2107
|
entries.AlarmNames = [];
|
|
2108
2108
|
}
|
|
2109
2109
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2111,12 +2111,12 @@ const se_DescribeAlarmsInput = (input, context) => {
|
|
|
2111
2111
|
entries[loc] = value;
|
|
2112
2112
|
});
|
|
2113
2113
|
}
|
|
2114
|
-
if (input
|
|
2115
|
-
entries[
|
|
2114
|
+
if (input[_ANP] != null) {
|
|
2115
|
+
entries[_ANP] = input[_ANP];
|
|
2116
2116
|
}
|
|
2117
|
-
if (input
|
|
2118
|
-
const memberEntries = se_AlarmTypes(input
|
|
2119
|
-
if (input
|
|
2117
|
+
if (input[_AT] != null) {
|
|
2118
|
+
const memberEntries = se_AlarmTypes(input[_AT], context);
|
|
2119
|
+
if (input[_AT]?.length === 0) {
|
|
2120
2120
|
entries.AlarmTypes = [];
|
|
2121
2121
|
}
|
|
2122
2122
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2124,43 +2124,43 @@ const se_DescribeAlarmsInput = (input, context) => {
|
|
|
2124
2124
|
entries[loc] = value;
|
|
2125
2125
|
});
|
|
2126
2126
|
}
|
|
2127
|
-
if (input
|
|
2128
|
-
entries[
|
|
2127
|
+
if (input[_COAN] != null) {
|
|
2128
|
+
entries[_COAN] = input[_COAN];
|
|
2129
2129
|
}
|
|
2130
|
-
if (input
|
|
2131
|
-
entries[
|
|
2130
|
+
if (input[_POAN] != null) {
|
|
2131
|
+
entries[_POAN] = input[_POAN];
|
|
2132
2132
|
}
|
|
2133
|
-
if (input
|
|
2134
|
-
entries[
|
|
2133
|
+
if (input[_SV] != null) {
|
|
2134
|
+
entries[_SV] = input[_SV];
|
|
2135
2135
|
}
|
|
2136
|
-
if (input
|
|
2137
|
-
entries[
|
|
2136
|
+
if (input[_AP] != null) {
|
|
2137
|
+
entries[_AP] = input[_AP];
|
|
2138
2138
|
}
|
|
2139
|
-
if (input
|
|
2140
|
-
entries[
|
|
2139
|
+
if (input[_MR] != null) {
|
|
2140
|
+
entries[_MR] = input[_MR];
|
|
2141
2141
|
}
|
|
2142
|
-
if (input
|
|
2143
|
-
entries[
|
|
2142
|
+
if (input[_NT] != null) {
|
|
2143
|
+
entries[_NT] = input[_NT];
|
|
2144
2144
|
}
|
|
2145
2145
|
return entries;
|
|
2146
2146
|
};
|
|
2147
2147
|
const se_DescribeAnomalyDetectorsInput = (input, context) => {
|
|
2148
2148
|
const entries = {};
|
|
2149
|
-
if (input
|
|
2150
|
-
entries[
|
|
2149
|
+
if (input[_NT] != null) {
|
|
2150
|
+
entries[_NT] = input[_NT];
|
|
2151
2151
|
}
|
|
2152
|
-
if (input
|
|
2153
|
-
entries[
|
|
2152
|
+
if (input[_MRa] != null) {
|
|
2153
|
+
entries[_MRa] = input[_MRa];
|
|
2154
2154
|
}
|
|
2155
|
-
if (input
|
|
2156
|
-
entries[
|
|
2155
|
+
if (input[_N] != null) {
|
|
2156
|
+
entries[_N] = input[_N];
|
|
2157
2157
|
}
|
|
2158
|
-
if (input
|
|
2159
|
-
entries[
|
|
2158
|
+
if (input[_MN] != null) {
|
|
2159
|
+
entries[_MN] = input[_MN];
|
|
2160
2160
|
}
|
|
2161
|
-
if (input
|
|
2162
|
-
const memberEntries = se_Dimensions(input
|
|
2163
|
-
if (input
|
|
2161
|
+
if (input[_D] != null) {
|
|
2162
|
+
const memberEntries = se_Dimensions(input[_D], context);
|
|
2163
|
+
if (input[_D]?.length === 0) {
|
|
2164
2164
|
entries.Dimensions = [];
|
|
2165
2165
|
}
|
|
2166
2166
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2168,9 +2168,9 @@ const se_DescribeAnomalyDetectorsInput = (input, context) => {
|
|
|
2168
2168
|
entries[loc] = value;
|
|
2169
2169
|
});
|
|
2170
2170
|
}
|
|
2171
|
-
if (input
|
|
2172
|
-
const memberEntries = se_AnomalyDetectorTypes(input
|
|
2173
|
-
if (input
|
|
2171
|
+
if (input[_ADT] != null) {
|
|
2172
|
+
const memberEntries = se_AnomalyDetectorTypes(input[_ADT], context);
|
|
2173
|
+
if (input[_ADT]?.length === 0) {
|
|
2174
2174
|
entries.AnomalyDetectorTypes = [];
|
|
2175
2175
|
}
|
|
2176
2176
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2182,31 +2182,31 @@ const se_DescribeAnomalyDetectorsInput = (input, context) => {
|
|
|
2182
2182
|
};
|
|
2183
2183
|
const se_DescribeInsightRulesInput = (input, context) => {
|
|
2184
2184
|
const entries = {};
|
|
2185
|
-
if (input
|
|
2186
|
-
entries[
|
|
2185
|
+
if (input[_NT] != null) {
|
|
2186
|
+
entries[_NT] = input[_NT];
|
|
2187
2187
|
}
|
|
2188
|
-
if (input
|
|
2189
|
-
entries[
|
|
2188
|
+
if (input[_MRa] != null) {
|
|
2189
|
+
entries[_MRa] = input[_MRa];
|
|
2190
2190
|
}
|
|
2191
2191
|
return entries;
|
|
2192
2192
|
};
|
|
2193
2193
|
const se_Dimension = (input, context) => {
|
|
2194
2194
|
const entries = {};
|
|
2195
|
-
if (input
|
|
2196
|
-
entries[
|
|
2195
|
+
if (input[_Na] != null) {
|
|
2196
|
+
entries[_Na] = input[_Na];
|
|
2197
2197
|
}
|
|
2198
|
-
if (input
|
|
2199
|
-
entries[
|
|
2198
|
+
if (input[_Va] != null) {
|
|
2199
|
+
entries[_Va] = input[_Va];
|
|
2200
2200
|
}
|
|
2201
2201
|
return entries;
|
|
2202
2202
|
};
|
|
2203
2203
|
const se_DimensionFilter = (input, context) => {
|
|
2204
2204
|
const entries = {};
|
|
2205
|
-
if (input
|
|
2206
|
-
entries[
|
|
2205
|
+
if (input[_Na] != null) {
|
|
2206
|
+
entries[_Na] = input[_Na];
|
|
2207
2207
|
}
|
|
2208
|
-
if (input
|
|
2209
|
-
entries[
|
|
2208
|
+
if (input[_Va] != null) {
|
|
2209
|
+
entries[_Va] = input[_Va];
|
|
2210
2210
|
}
|
|
2211
2211
|
return entries;
|
|
2212
2212
|
};
|
|
@@ -2242,9 +2242,9 @@ const se_Dimensions = (input, context) => {
|
|
|
2242
2242
|
};
|
|
2243
2243
|
const se_DisableAlarmActionsInput = (input, context) => {
|
|
2244
2244
|
const entries = {};
|
|
2245
|
-
if (input
|
|
2246
|
-
const memberEntries = se_AlarmNames(input
|
|
2247
|
-
if (input
|
|
2245
|
+
if (input[_AN] != null) {
|
|
2246
|
+
const memberEntries = se_AlarmNames(input[_AN], context);
|
|
2247
|
+
if (input[_AN]?.length === 0) {
|
|
2248
2248
|
entries.AlarmNames = [];
|
|
2249
2249
|
}
|
|
2250
2250
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2256,9 +2256,9 @@ const se_DisableAlarmActionsInput = (input, context) => {
|
|
|
2256
2256
|
};
|
|
2257
2257
|
const se_DisableInsightRulesInput = (input, context) => {
|
|
2258
2258
|
const entries = {};
|
|
2259
|
-
if (input
|
|
2260
|
-
const memberEntries = se_InsightRuleNames(input
|
|
2261
|
-
if (input
|
|
2259
|
+
if (input[_RN] != null) {
|
|
2260
|
+
const memberEntries = se_InsightRuleNames(input[_RN], context);
|
|
2261
|
+
if (input[_RN]?.length === 0) {
|
|
2262
2262
|
entries.RuleNames = [];
|
|
2263
2263
|
}
|
|
2264
2264
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2270,9 +2270,9 @@ const se_DisableInsightRulesInput = (input, context) => {
|
|
|
2270
2270
|
};
|
|
2271
2271
|
const se_EnableAlarmActionsInput = (input, context) => {
|
|
2272
2272
|
const entries = {};
|
|
2273
|
-
if (input
|
|
2274
|
-
const memberEntries = se_AlarmNames(input
|
|
2275
|
-
if (input
|
|
2273
|
+
if (input[_AN] != null) {
|
|
2274
|
+
const memberEntries = se_AlarmNames(input[_AN], context);
|
|
2275
|
+
if (input[_AN]?.length === 0) {
|
|
2276
2276
|
entries.AlarmNames = [];
|
|
2277
2277
|
}
|
|
2278
2278
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2284,9 +2284,9 @@ const se_EnableAlarmActionsInput = (input, context) => {
|
|
|
2284
2284
|
};
|
|
2285
2285
|
const se_EnableInsightRulesInput = (input, context) => {
|
|
2286
2286
|
const entries = {};
|
|
2287
|
-
if (input
|
|
2288
|
-
const memberEntries = se_InsightRuleNames(input
|
|
2289
|
-
if (input
|
|
2287
|
+
if (input[_RN] != null) {
|
|
2288
|
+
const memberEntries = se_InsightRuleNames(input[_RN], context);
|
|
2289
|
+
if (input[_RN]?.length === 0) {
|
|
2290
2290
|
entries.RuleNames = [];
|
|
2291
2291
|
}
|
|
2292
2292
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2310,31 +2310,31 @@ const se_ExtendedStatistics = (input, context) => {
|
|
|
2310
2310
|
};
|
|
2311
2311
|
const se_GetDashboardInput = (input, context) => {
|
|
2312
2312
|
const entries = {};
|
|
2313
|
-
if (input
|
|
2314
|
-
entries[
|
|
2313
|
+
if (input[_DNa] != null) {
|
|
2314
|
+
entries[_DNa] = input[_DNa];
|
|
2315
2315
|
}
|
|
2316
2316
|
return entries;
|
|
2317
2317
|
};
|
|
2318
2318
|
const se_GetInsightRuleReportInput = (input, context) => {
|
|
2319
2319
|
const entries = {};
|
|
2320
|
-
if (input
|
|
2321
|
-
entries[
|
|
2320
|
+
if (input[_RNu] != null) {
|
|
2321
|
+
entries[_RNu] = input[_RNu];
|
|
2322
2322
|
}
|
|
2323
|
-
if (input
|
|
2324
|
-
entries[
|
|
2323
|
+
if (input[_ST] != null) {
|
|
2324
|
+
entries[_ST] = input[_ST].toISOString().split(".")[0] + "Z";
|
|
2325
2325
|
}
|
|
2326
|
-
if (input
|
|
2327
|
-
entries[
|
|
2326
|
+
if (input[_ET] != null) {
|
|
2327
|
+
entries[_ET] = input[_ET].toISOString().split(".")[0] + "Z";
|
|
2328
2328
|
}
|
|
2329
|
-
if (input
|
|
2330
|
-
entries[
|
|
2329
|
+
if (input[_P] != null) {
|
|
2330
|
+
entries[_P] = input[_P];
|
|
2331
2331
|
}
|
|
2332
|
-
if (input
|
|
2333
|
-
entries[
|
|
2332
|
+
if (input[_MCC] != null) {
|
|
2333
|
+
entries[_MCC] = input[_MCC];
|
|
2334
2334
|
}
|
|
2335
|
-
if (input
|
|
2336
|
-
const memberEntries = se_InsightRuleMetricList(input
|
|
2337
|
-
if (input
|
|
2335
|
+
if (input[_M] != null) {
|
|
2336
|
+
const memberEntries = se_InsightRuleMetricList(input[_M], context);
|
|
2337
|
+
if (input[_M]?.length === 0) {
|
|
2338
2338
|
entries.Metrics = [];
|
|
2339
2339
|
}
|
|
2340
2340
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2342,16 +2342,16 @@ const se_GetInsightRuleReportInput = (input, context) => {
|
|
|
2342
2342
|
entries[loc] = value;
|
|
2343
2343
|
});
|
|
2344
2344
|
}
|
|
2345
|
-
if (input
|
|
2346
|
-
entries[
|
|
2345
|
+
if (input[_OB] != null) {
|
|
2346
|
+
entries[_OB] = input[_OB];
|
|
2347
2347
|
}
|
|
2348
2348
|
return entries;
|
|
2349
2349
|
};
|
|
2350
2350
|
const se_GetMetricDataInput = (input, context) => {
|
|
2351
2351
|
const entries = {};
|
|
2352
|
-
if (input
|
|
2353
|
-
const memberEntries = se_MetricDataQueries(input
|
|
2354
|
-
if (input
|
|
2352
|
+
if (input[_MDQ] != null) {
|
|
2353
|
+
const memberEntries = se_MetricDataQueries(input[_MDQ], context);
|
|
2354
|
+
if (input[_MDQ]?.length === 0) {
|
|
2355
2355
|
entries.MetricDataQueries = [];
|
|
2356
2356
|
}
|
|
2357
2357
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2359,23 +2359,23 @@ const se_GetMetricDataInput = (input, context) => {
|
|
|
2359
2359
|
entries[loc] = value;
|
|
2360
2360
|
});
|
|
2361
2361
|
}
|
|
2362
|
-
if (input
|
|
2363
|
-
entries[
|
|
2362
|
+
if (input[_ST] != null) {
|
|
2363
|
+
entries[_ST] = input[_ST].toISOString().split(".")[0] + "Z";
|
|
2364
2364
|
}
|
|
2365
|
-
if (input
|
|
2366
|
-
entries[
|
|
2365
|
+
if (input[_ET] != null) {
|
|
2366
|
+
entries[_ET] = input[_ET].toISOString().split(".")[0] + "Z";
|
|
2367
2367
|
}
|
|
2368
|
-
if (input
|
|
2369
|
-
entries[
|
|
2368
|
+
if (input[_NT] != null) {
|
|
2369
|
+
entries[_NT] = input[_NT];
|
|
2370
2370
|
}
|
|
2371
|
-
if (input
|
|
2372
|
-
entries[
|
|
2371
|
+
if (input[_SB] != null) {
|
|
2372
|
+
entries[_SB] = input[_SB];
|
|
2373
2373
|
}
|
|
2374
|
-
if (input
|
|
2375
|
-
entries[
|
|
2374
|
+
if (input[_MD] != null) {
|
|
2375
|
+
entries[_MD] = input[_MD];
|
|
2376
2376
|
}
|
|
2377
|
-
if (input
|
|
2378
|
-
const memberEntries = se_LabelOptions(input
|
|
2377
|
+
if (input[_LO] != null) {
|
|
2378
|
+
const memberEntries = se_LabelOptions(input[_LO], context);
|
|
2379
2379
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2380
2380
|
const loc = `LabelOptions.${key}`;
|
|
2381
2381
|
entries[loc] = value;
|
|
@@ -2385,15 +2385,15 @@ const se_GetMetricDataInput = (input, context) => {
|
|
|
2385
2385
|
};
|
|
2386
2386
|
const se_GetMetricStatisticsInput = (input, context) => {
|
|
2387
2387
|
const entries = {};
|
|
2388
|
-
if (input
|
|
2389
|
-
entries[
|
|
2388
|
+
if (input[_N] != null) {
|
|
2389
|
+
entries[_N] = input[_N];
|
|
2390
2390
|
}
|
|
2391
|
-
if (input
|
|
2392
|
-
entries[
|
|
2391
|
+
if (input[_MN] != null) {
|
|
2392
|
+
entries[_MN] = input[_MN];
|
|
2393
2393
|
}
|
|
2394
|
-
if (input
|
|
2395
|
-
const memberEntries = se_Dimensions(input
|
|
2396
|
-
if (input
|
|
2394
|
+
if (input[_D] != null) {
|
|
2395
|
+
const memberEntries = se_Dimensions(input[_D], context);
|
|
2396
|
+
if (input[_D]?.length === 0) {
|
|
2397
2397
|
entries.Dimensions = [];
|
|
2398
2398
|
}
|
|
2399
2399
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2401,18 +2401,18 @@ const se_GetMetricStatisticsInput = (input, context) => {
|
|
|
2401
2401
|
entries[loc] = value;
|
|
2402
2402
|
});
|
|
2403
2403
|
}
|
|
2404
|
-
if (input
|
|
2405
|
-
entries[
|
|
2404
|
+
if (input[_ST] != null) {
|
|
2405
|
+
entries[_ST] = input[_ST].toISOString().split(".")[0] + "Z";
|
|
2406
2406
|
}
|
|
2407
|
-
if (input
|
|
2408
|
-
entries[
|
|
2407
|
+
if (input[_ET] != null) {
|
|
2408
|
+
entries[_ET] = input[_ET].toISOString().split(".")[0] + "Z";
|
|
2409
2409
|
}
|
|
2410
|
-
if (input
|
|
2411
|
-
entries[
|
|
2410
|
+
if (input[_P] != null) {
|
|
2411
|
+
entries[_P] = input[_P];
|
|
2412
2412
|
}
|
|
2413
|
-
if (input
|
|
2414
|
-
const memberEntries = se_Statistics(input
|
|
2415
|
-
if (input
|
|
2413
|
+
if (input[_Sta] != null) {
|
|
2414
|
+
const memberEntries = se_Statistics(input[_Sta], context);
|
|
2415
|
+
if (input[_Sta]?.length === 0) {
|
|
2416
2416
|
entries.Statistics = [];
|
|
2417
2417
|
}
|
|
2418
2418
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2420,9 +2420,9 @@ const se_GetMetricStatisticsInput = (input, context) => {
|
|
|
2420
2420
|
entries[loc] = value;
|
|
2421
2421
|
});
|
|
2422
2422
|
}
|
|
2423
|
-
if (input
|
|
2424
|
-
const memberEntries = se_ExtendedStatistics(input
|
|
2425
|
-
if (input
|
|
2423
|
+
if (input[_ESx] != null) {
|
|
2424
|
+
const memberEntries = se_ExtendedStatistics(input[_ESx], context);
|
|
2425
|
+
if (input[_ESx]?.length === 0) {
|
|
2426
2426
|
entries.ExtendedStatistics = [];
|
|
2427
2427
|
}
|
|
2428
2428
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2430,25 +2430,25 @@ const se_GetMetricStatisticsInput = (input, context) => {
|
|
|
2430
2430
|
entries[loc] = value;
|
|
2431
2431
|
});
|
|
2432
2432
|
}
|
|
2433
|
-
if (input
|
|
2434
|
-
entries[
|
|
2433
|
+
if (input[_U] != null) {
|
|
2434
|
+
entries[_U] = input[_U];
|
|
2435
2435
|
}
|
|
2436
2436
|
return entries;
|
|
2437
2437
|
};
|
|
2438
2438
|
const se_GetMetricStreamInput = (input, context) => {
|
|
2439
2439
|
const entries = {};
|
|
2440
|
-
if (input
|
|
2441
|
-
entries[
|
|
2440
|
+
if (input[_Na] != null) {
|
|
2441
|
+
entries[_Na] = input[_Na];
|
|
2442
2442
|
}
|
|
2443
2443
|
return entries;
|
|
2444
2444
|
};
|
|
2445
2445
|
const se_GetMetricWidgetImageInput = (input, context) => {
|
|
2446
2446
|
const entries = {};
|
|
2447
|
-
if (input
|
|
2448
|
-
entries[
|
|
2447
|
+
if (input[_MW] != null) {
|
|
2448
|
+
entries[_MW] = input[_MW];
|
|
2449
2449
|
}
|
|
2450
|
-
if (input
|
|
2451
|
-
entries[
|
|
2450
|
+
if (input[_OF] != null) {
|
|
2451
|
+
entries[_OF] = input[_OF];
|
|
2452
2452
|
}
|
|
2453
2453
|
return entries;
|
|
2454
2454
|
};
|
|
@@ -2478,45 +2478,45 @@ const se_InsightRuleNames = (input, context) => {
|
|
|
2478
2478
|
};
|
|
2479
2479
|
const se_LabelOptions = (input, context) => {
|
|
2480
2480
|
const entries = {};
|
|
2481
|
-
if (input
|
|
2482
|
-
entries[
|
|
2481
|
+
if (input[_T] != null) {
|
|
2482
|
+
entries[_T] = input[_T];
|
|
2483
2483
|
}
|
|
2484
2484
|
return entries;
|
|
2485
2485
|
};
|
|
2486
2486
|
const se_ListDashboardsInput = (input, context) => {
|
|
2487
2487
|
const entries = {};
|
|
2488
|
-
if (input
|
|
2489
|
-
entries[
|
|
2488
|
+
if (input[_DNP] != null) {
|
|
2489
|
+
entries[_DNP] = input[_DNP];
|
|
2490
2490
|
}
|
|
2491
|
-
if (input
|
|
2492
|
-
entries[
|
|
2491
|
+
if (input[_NT] != null) {
|
|
2492
|
+
entries[_NT] = input[_NT];
|
|
2493
2493
|
}
|
|
2494
2494
|
return entries;
|
|
2495
2495
|
};
|
|
2496
2496
|
const se_ListManagedInsightRulesInput = (input, context) => {
|
|
2497
2497
|
const entries = {};
|
|
2498
|
-
if (input
|
|
2499
|
-
entries[
|
|
2498
|
+
if (input[_RARN] != null) {
|
|
2499
|
+
entries[_RARN] = input[_RARN];
|
|
2500
2500
|
}
|
|
2501
|
-
if (input
|
|
2502
|
-
entries[
|
|
2501
|
+
if (input[_NT] != null) {
|
|
2502
|
+
entries[_NT] = input[_NT];
|
|
2503
2503
|
}
|
|
2504
|
-
if (input
|
|
2505
|
-
entries[
|
|
2504
|
+
if (input[_MRa] != null) {
|
|
2505
|
+
entries[_MRa] = input[_MRa];
|
|
2506
2506
|
}
|
|
2507
2507
|
return entries;
|
|
2508
2508
|
};
|
|
2509
2509
|
const se_ListMetricsInput = (input, context) => {
|
|
2510
2510
|
const entries = {};
|
|
2511
|
-
if (input
|
|
2512
|
-
entries[
|
|
2511
|
+
if (input[_N] != null) {
|
|
2512
|
+
entries[_N] = input[_N];
|
|
2513
2513
|
}
|
|
2514
|
-
if (input
|
|
2515
|
-
entries[
|
|
2514
|
+
if (input[_MN] != null) {
|
|
2515
|
+
entries[_MN] = input[_MN];
|
|
2516
2516
|
}
|
|
2517
|
-
if (input
|
|
2518
|
-
const memberEntries = se_DimensionFilters(input
|
|
2519
|
-
if (input
|
|
2517
|
+
if (input[_D] != null) {
|
|
2518
|
+
const memberEntries = se_DimensionFilters(input[_D], context);
|
|
2519
|
+
if (input[_D]?.length === 0) {
|
|
2520
2520
|
entries.Dimensions = [];
|
|
2521
2521
|
}
|
|
2522
2522
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2524,48 +2524,48 @@ const se_ListMetricsInput = (input, context) => {
|
|
|
2524
2524
|
entries[loc] = value;
|
|
2525
2525
|
});
|
|
2526
2526
|
}
|
|
2527
|
-
if (input
|
|
2528
|
-
entries[
|
|
2527
|
+
if (input[_NT] != null) {
|
|
2528
|
+
entries[_NT] = input[_NT];
|
|
2529
2529
|
}
|
|
2530
|
-
if (input
|
|
2531
|
-
entries[
|
|
2530
|
+
if (input[_RA] != null) {
|
|
2531
|
+
entries[_RA] = input[_RA];
|
|
2532
2532
|
}
|
|
2533
|
-
if (input
|
|
2534
|
-
entries[
|
|
2533
|
+
if (input[_ILA] != null) {
|
|
2534
|
+
entries[_ILA] = input[_ILA];
|
|
2535
2535
|
}
|
|
2536
|
-
if (input
|
|
2537
|
-
entries[
|
|
2536
|
+
if (input[_OA] != null) {
|
|
2537
|
+
entries[_OA] = input[_OA];
|
|
2538
2538
|
}
|
|
2539
2539
|
return entries;
|
|
2540
2540
|
};
|
|
2541
2541
|
const se_ListMetricStreamsInput = (input, context) => {
|
|
2542
2542
|
const entries = {};
|
|
2543
|
-
if (input
|
|
2544
|
-
entries[
|
|
2543
|
+
if (input[_NT] != null) {
|
|
2544
|
+
entries[_NT] = input[_NT];
|
|
2545
2545
|
}
|
|
2546
|
-
if (input
|
|
2547
|
-
entries[
|
|
2546
|
+
if (input[_MRa] != null) {
|
|
2547
|
+
entries[_MRa] = input[_MRa];
|
|
2548
2548
|
}
|
|
2549
2549
|
return entries;
|
|
2550
2550
|
};
|
|
2551
2551
|
const se_ListTagsForResourceInput = (input, context) => {
|
|
2552
2552
|
const entries = {};
|
|
2553
|
-
if (input
|
|
2554
|
-
entries[
|
|
2553
|
+
if (input[_RARN] != null) {
|
|
2554
|
+
entries[_RARN] = input[_RARN];
|
|
2555
2555
|
}
|
|
2556
2556
|
return entries;
|
|
2557
2557
|
};
|
|
2558
2558
|
const se_ManagedRule = (input, context) => {
|
|
2559
2559
|
const entries = {};
|
|
2560
|
-
if (input
|
|
2561
|
-
entries[
|
|
2560
|
+
if (input[_TN] != null) {
|
|
2561
|
+
entries[_TN] = input[_TN];
|
|
2562
2562
|
}
|
|
2563
|
-
if (input
|
|
2564
|
-
entries[
|
|
2563
|
+
if (input[_RARN] != null) {
|
|
2564
|
+
entries[_RARN] = input[_RARN];
|
|
2565
2565
|
}
|
|
2566
|
-
if (input
|
|
2567
|
-
const memberEntries = se_TagList(input
|
|
2568
|
-
if (input
|
|
2566
|
+
if (input[_Ta] != null) {
|
|
2567
|
+
const memberEntries = se_TagList(input[_Ta], context);
|
|
2568
|
+
if (input[_Ta]?.length === 0) {
|
|
2569
2569
|
entries.Tags = [];
|
|
2570
2570
|
}
|
|
2571
2571
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2592,15 +2592,15 @@ const se_ManagedRules = (input, context) => {
|
|
|
2592
2592
|
};
|
|
2593
2593
|
const se_Metric = (input, context) => {
|
|
2594
2594
|
const entries = {};
|
|
2595
|
-
if (input
|
|
2596
|
-
entries[
|
|
2595
|
+
if (input[_N] != null) {
|
|
2596
|
+
entries[_N] = input[_N];
|
|
2597
2597
|
}
|
|
2598
|
-
if (input
|
|
2599
|
-
entries[
|
|
2598
|
+
if (input[_MN] != null) {
|
|
2599
|
+
entries[_MN] = input[_MN];
|
|
2600
2600
|
}
|
|
2601
|
-
if (input
|
|
2602
|
-
const memberEntries = se_Dimensions(input
|
|
2603
|
-
if (input
|
|
2601
|
+
if (input[_D] != null) {
|
|
2602
|
+
const memberEntries = se_Dimensions(input[_D], context);
|
|
2603
|
+
if (input[_D]?.length === 0) {
|
|
2604
2604
|
entries.Dimensions = [];
|
|
2605
2605
|
}
|
|
2606
2606
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2642,41 +2642,41 @@ const se_MetricDataQueries = (input, context) => {
|
|
|
2642
2642
|
};
|
|
2643
2643
|
const se_MetricDataQuery = (input, context) => {
|
|
2644
2644
|
const entries = {};
|
|
2645
|
-
if (input
|
|
2646
|
-
entries[
|
|
2645
|
+
if (input[_I] != null) {
|
|
2646
|
+
entries[_I] = input[_I];
|
|
2647
2647
|
}
|
|
2648
|
-
if (input
|
|
2649
|
-
const memberEntries = se_MetricStat(input
|
|
2648
|
+
if (input[_MS] != null) {
|
|
2649
|
+
const memberEntries = se_MetricStat(input[_MS], context);
|
|
2650
2650
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2651
2651
|
const loc = `MetricStat.${key}`;
|
|
2652
2652
|
entries[loc] = value;
|
|
2653
2653
|
});
|
|
2654
2654
|
}
|
|
2655
|
-
if (input
|
|
2656
|
-
entries[
|
|
2655
|
+
if (input[_E] != null) {
|
|
2656
|
+
entries[_E] = input[_E];
|
|
2657
2657
|
}
|
|
2658
|
-
if (input
|
|
2659
|
-
entries[
|
|
2658
|
+
if (input[_L] != null) {
|
|
2659
|
+
entries[_L] = input[_L];
|
|
2660
2660
|
}
|
|
2661
|
-
if (input
|
|
2662
|
-
entries[
|
|
2661
|
+
if (input[_RD] != null) {
|
|
2662
|
+
entries[_RD] = input[_RD];
|
|
2663
2663
|
}
|
|
2664
|
-
if (input
|
|
2665
|
-
entries[
|
|
2664
|
+
if (input[_P] != null) {
|
|
2665
|
+
entries[_P] = input[_P];
|
|
2666
2666
|
}
|
|
2667
|
-
if (input
|
|
2668
|
-
entries[
|
|
2667
|
+
if (input[_AI] != null) {
|
|
2668
|
+
entries[_AI] = input[_AI];
|
|
2669
2669
|
}
|
|
2670
2670
|
return entries;
|
|
2671
2671
|
};
|
|
2672
2672
|
const se_MetricDatum = (input, context) => {
|
|
2673
2673
|
const entries = {};
|
|
2674
|
-
if (input
|
|
2675
|
-
entries[
|
|
2674
|
+
if (input[_MN] != null) {
|
|
2675
|
+
entries[_MN] = input[_MN];
|
|
2676
2676
|
}
|
|
2677
|
-
if (input
|
|
2678
|
-
const memberEntries = se_Dimensions(input
|
|
2679
|
-
if (input
|
|
2677
|
+
if (input[_D] != null) {
|
|
2678
|
+
const memberEntries = se_Dimensions(input[_D], context);
|
|
2679
|
+
if (input[_D]?.length === 0) {
|
|
2680
2680
|
entries.Dimensions = [];
|
|
2681
2681
|
}
|
|
2682
2682
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2684,22 +2684,22 @@ const se_MetricDatum = (input, context) => {
|
|
|
2684
2684
|
entries[loc] = value;
|
|
2685
2685
|
});
|
|
2686
2686
|
}
|
|
2687
|
-
if (input
|
|
2688
|
-
entries[
|
|
2687
|
+
if (input[_Ti] != null) {
|
|
2688
|
+
entries[_Ti] = input[_Ti].toISOString().split(".")[0] + "Z";
|
|
2689
2689
|
}
|
|
2690
|
-
if (input
|
|
2691
|
-
entries[
|
|
2690
|
+
if (input[_Va] != null) {
|
|
2691
|
+
entries[_Va] = __serializeFloat(input[_Va]);
|
|
2692
2692
|
}
|
|
2693
|
-
if (input
|
|
2694
|
-
const memberEntries = se_StatisticSet(input
|
|
2693
|
+
if (input[_SVt] != null) {
|
|
2694
|
+
const memberEntries = se_StatisticSet(input[_SVt], context);
|
|
2695
2695
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2696
2696
|
const loc = `StatisticValues.${key}`;
|
|
2697
2697
|
entries[loc] = value;
|
|
2698
2698
|
});
|
|
2699
2699
|
}
|
|
2700
|
-
if (input
|
|
2701
|
-
const memberEntries = se_Values(input
|
|
2702
|
-
if (input
|
|
2700
|
+
if (input[_Val] != null) {
|
|
2701
|
+
const memberEntries = se_Values(input[_Val], context);
|
|
2702
|
+
if (input[_Val]?.length === 0) {
|
|
2703
2703
|
entries.Values = [];
|
|
2704
2704
|
}
|
|
2705
2705
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2707,9 +2707,9 @@ const se_MetricDatum = (input, context) => {
|
|
|
2707
2707
|
entries[loc] = value;
|
|
2708
2708
|
});
|
|
2709
2709
|
}
|
|
2710
|
-
if (input
|
|
2711
|
-
const memberEntries = se_Counts(input
|
|
2712
|
-
if (input
|
|
2710
|
+
if (input[_C] != null) {
|
|
2711
|
+
const memberEntries = se_Counts(input[_C], context);
|
|
2712
|
+
if (input[_C]?.length === 0) {
|
|
2713
2713
|
entries.Counts = [];
|
|
2714
2714
|
}
|
|
2715
2715
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2717,19 +2717,19 @@ const se_MetricDatum = (input, context) => {
|
|
|
2717
2717
|
entries[loc] = value;
|
|
2718
2718
|
});
|
|
2719
2719
|
}
|
|
2720
|
-
if (input
|
|
2721
|
-
entries[
|
|
2720
|
+
if (input[_U] != null) {
|
|
2721
|
+
entries[_U] = input[_U];
|
|
2722
2722
|
}
|
|
2723
|
-
if (input
|
|
2724
|
-
entries[
|
|
2723
|
+
if (input[_SR] != null) {
|
|
2724
|
+
entries[_SR] = input[_SR];
|
|
2725
2725
|
}
|
|
2726
2726
|
return entries;
|
|
2727
2727
|
};
|
|
2728
2728
|
const se_MetricMathAnomalyDetector = (input, context) => {
|
|
2729
2729
|
const entries = {};
|
|
2730
|
-
if (input
|
|
2731
|
-
const memberEntries = se_MetricDataQueries(input
|
|
2732
|
-
if (input
|
|
2730
|
+
if (input[_MDQ] != null) {
|
|
2731
|
+
const memberEntries = se_MetricDataQueries(input[_MDQ], context);
|
|
2732
|
+
if (input[_MDQ]?.length === 0) {
|
|
2733
2733
|
entries.MetricDataQueries = [];
|
|
2734
2734
|
}
|
|
2735
2735
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2741,32 +2741,32 @@ const se_MetricMathAnomalyDetector = (input, context) => {
|
|
|
2741
2741
|
};
|
|
2742
2742
|
const se_MetricStat = (input, context) => {
|
|
2743
2743
|
const entries = {};
|
|
2744
|
-
if (input
|
|
2745
|
-
const memberEntries = se_Metric(input
|
|
2744
|
+
if (input[_Me] != null) {
|
|
2745
|
+
const memberEntries = se_Metric(input[_Me], context);
|
|
2746
2746
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2747
2747
|
const loc = `Metric.${key}`;
|
|
2748
2748
|
entries[loc] = value;
|
|
2749
2749
|
});
|
|
2750
2750
|
}
|
|
2751
|
-
if (input
|
|
2752
|
-
entries[
|
|
2751
|
+
if (input[_P] != null) {
|
|
2752
|
+
entries[_P] = input[_P];
|
|
2753
2753
|
}
|
|
2754
|
-
if (input
|
|
2755
|
-
entries[
|
|
2754
|
+
if (input[_S] != null) {
|
|
2755
|
+
entries[_S] = input[_S];
|
|
2756
2756
|
}
|
|
2757
|
-
if (input
|
|
2758
|
-
entries[
|
|
2757
|
+
if (input[_U] != null) {
|
|
2758
|
+
entries[_U] = input[_U];
|
|
2759
2759
|
}
|
|
2760
2760
|
return entries;
|
|
2761
2761
|
};
|
|
2762
2762
|
const se_MetricStreamFilter = (input, context) => {
|
|
2763
2763
|
const entries = {};
|
|
2764
|
-
if (input
|
|
2765
|
-
entries[
|
|
2764
|
+
if (input[_N] != null) {
|
|
2765
|
+
entries[_N] = input[_N];
|
|
2766
2766
|
}
|
|
2767
|
-
if (input
|
|
2768
|
-
const memberEntries = se_MetricStreamFilterMetricNames(input
|
|
2769
|
-
if (input
|
|
2767
|
+
if (input[_MNe] != null) {
|
|
2768
|
+
const memberEntries = se_MetricStreamFilterMetricNames(input[_MNe], context);
|
|
2769
|
+
if (input[_MNe]?.length === 0) {
|
|
2770
2770
|
entries.MetricNames = [];
|
|
2771
2771
|
}
|
|
2772
2772
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2829,9 +2829,9 @@ const se_MetricStreamStatisticsAdditionalStatistics = (input, context) => {
|
|
|
2829
2829
|
};
|
|
2830
2830
|
const se_MetricStreamStatisticsConfiguration = (input, context) => {
|
|
2831
2831
|
const entries = {};
|
|
2832
|
-
if (input
|
|
2833
|
-
const memberEntries = se_MetricStreamStatisticsIncludeMetrics(input
|
|
2834
|
-
if (input
|
|
2832
|
+
if (input[_IM] != null) {
|
|
2833
|
+
const memberEntries = se_MetricStreamStatisticsIncludeMetrics(input[_IM], context);
|
|
2834
|
+
if (input[_IM]?.length === 0) {
|
|
2835
2835
|
entries.IncludeMetrics = [];
|
|
2836
2836
|
}
|
|
2837
2837
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2839,9 +2839,9 @@ const se_MetricStreamStatisticsConfiguration = (input, context) => {
|
|
|
2839
2839
|
entries[loc] = value;
|
|
2840
2840
|
});
|
|
2841
2841
|
}
|
|
2842
|
-
if (input
|
|
2843
|
-
const memberEntries = se_MetricStreamStatisticsAdditionalStatistics(input
|
|
2844
|
-
if (input
|
|
2842
|
+
if (input[_AS] != null) {
|
|
2843
|
+
const memberEntries = se_MetricStreamStatisticsAdditionalStatistics(input[_AS], context);
|
|
2844
|
+
if (input[_AS]?.length === 0) {
|
|
2845
2845
|
entries.AdditionalStatistics = [];
|
|
2846
2846
|
}
|
|
2847
2847
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2883,25 +2883,25 @@ const se_MetricStreamStatisticsIncludeMetrics = (input, context) => {
|
|
|
2883
2883
|
};
|
|
2884
2884
|
const se_MetricStreamStatisticsMetric = (input, context) => {
|
|
2885
2885
|
const entries = {};
|
|
2886
|
-
if (input
|
|
2887
|
-
entries[
|
|
2886
|
+
if (input[_N] != null) {
|
|
2887
|
+
entries[_N] = input[_N];
|
|
2888
2888
|
}
|
|
2889
|
-
if (input
|
|
2890
|
-
entries[
|
|
2889
|
+
if (input[_MN] != null) {
|
|
2890
|
+
entries[_MN] = input[_MN];
|
|
2891
2891
|
}
|
|
2892
2892
|
return entries;
|
|
2893
2893
|
};
|
|
2894
2894
|
const se_PutAnomalyDetectorInput = (input, context) => {
|
|
2895
2895
|
const entries = {};
|
|
2896
|
-
if (input
|
|
2897
|
-
entries[
|
|
2896
|
+
if (input[_N] != null) {
|
|
2897
|
+
entries[_N] = input[_N];
|
|
2898
2898
|
}
|
|
2899
|
-
if (input
|
|
2900
|
-
entries[
|
|
2899
|
+
if (input[_MN] != null) {
|
|
2900
|
+
entries[_MN] = input[_MN];
|
|
2901
2901
|
}
|
|
2902
|
-
if (input
|
|
2903
|
-
const memberEntries = se_Dimensions(input
|
|
2904
|
-
if (input
|
|
2902
|
+
if (input[_D] != null) {
|
|
2903
|
+
const memberEntries = se_Dimensions(input[_D], context);
|
|
2904
|
+
if (input[_D]?.length === 0) {
|
|
2905
2905
|
entries.Dimensions = [];
|
|
2906
2906
|
}
|
|
2907
2907
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2909,25 +2909,25 @@ const se_PutAnomalyDetectorInput = (input, context) => {
|
|
|
2909
2909
|
entries[loc] = value;
|
|
2910
2910
|
});
|
|
2911
2911
|
}
|
|
2912
|
-
if (input
|
|
2913
|
-
entries[
|
|
2912
|
+
if (input[_S] != null) {
|
|
2913
|
+
entries[_S] = input[_S];
|
|
2914
2914
|
}
|
|
2915
|
-
if (input
|
|
2916
|
-
const memberEntries = se_AnomalyDetectorConfiguration(input
|
|
2915
|
+
if (input[_Co] != null) {
|
|
2916
|
+
const memberEntries = se_AnomalyDetectorConfiguration(input[_Co], context);
|
|
2917
2917
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2918
2918
|
const loc = `Configuration.${key}`;
|
|
2919
2919
|
entries[loc] = value;
|
|
2920
2920
|
});
|
|
2921
2921
|
}
|
|
2922
|
-
if (input
|
|
2923
|
-
const memberEntries = se_SingleMetricAnomalyDetector(input
|
|
2922
|
+
if (input[_SMAD] != null) {
|
|
2923
|
+
const memberEntries = se_SingleMetricAnomalyDetector(input[_SMAD], context);
|
|
2924
2924
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2925
2925
|
const loc = `SingleMetricAnomalyDetector.${key}`;
|
|
2926
2926
|
entries[loc] = value;
|
|
2927
2927
|
});
|
|
2928
2928
|
}
|
|
2929
|
-
if (input
|
|
2930
|
-
const memberEntries = se_MetricMathAnomalyDetector(input
|
|
2929
|
+
if (input[_MMAD] != null) {
|
|
2930
|
+
const memberEntries = se_MetricMathAnomalyDetector(input[_MMAD], context);
|
|
2931
2931
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2932
2932
|
const loc = `MetricMathAnomalyDetector.${key}`;
|
|
2933
2933
|
entries[loc] = value;
|
|
@@ -2937,12 +2937,12 @@ const se_PutAnomalyDetectorInput = (input, context) => {
|
|
|
2937
2937
|
};
|
|
2938
2938
|
const se_PutCompositeAlarmInput = (input, context) => {
|
|
2939
2939
|
const entries = {};
|
|
2940
|
-
if (input
|
|
2941
|
-
entries[
|
|
2940
|
+
if (input[_AE] != null) {
|
|
2941
|
+
entries[_AE] = input[_AE];
|
|
2942
2942
|
}
|
|
2943
|
-
if (input
|
|
2944
|
-
const memberEntries = se_ResourceList(input
|
|
2945
|
-
if (input
|
|
2943
|
+
if (input[_AA] != null) {
|
|
2944
|
+
const memberEntries = se_ResourceList(input[_AA], context);
|
|
2945
|
+
if (input[_AA]?.length === 0) {
|
|
2946
2946
|
entries.AlarmActions = [];
|
|
2947
2947
|
}
|
|
2948
2948
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2950,18 +2950,18 @@ const se_PutCompositeAlarmInput = (input, context) => {
|
|
|
2950
2950
|
entries[loc] = value;
|
|
2951
2951
|
});
|
|
2952
2952
|
}
|
|
2953
|
-
if (input
|
|
2954
|
-
entries[
|
|
2953
|
+
if (input[_AD] != null) {
|
|
2954
|
+
entries[_AD] = input[_AD];
|
|
2955
2955
|
}
|
|
2956
|
-
if (input
|
|
2957
|
-
entries[
|
|
2956
|
+
if (input[_ANl] != null) {
|
|
2957
|
+
entries[_ANl] = input[_ANl];
|
|
2958
2958
|
}
|
|
2959
|
-
if (input
|
|
2960
|
-
entries[
|
|
2959
|
+
if (input[_AR] != null) {
|
|
2960
|
+
entries[_AR] = input[_AR];
|
|
2961
2961
|
}
|
|
2962
|
-
if (input
|
|
2963
|
-
const memberEntries = se_ResourceList(input
|
|
2964
|
-
if (input
|
|
2962
|
+
if (input[_IDA] != null) {
|
|
2963
|
+
const memberEntries = se_ResourceList(input[_IDA], context);
|
|
2964
|
+
if (input[_IDA]?.length === 0) {
|
|
2965
2965
|
entries.InsufficientDataActions = [];
|
|
2966
2966
|
}
|
|
2967
2967
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2969,9 +2969,9 @@ const se_PutCompositeAlarmInput = (input, context) => {
|
|
|
2969
2969
|
entries[loc] = value;
|
|
2970
2970
|
});
|
|
2971
2971
|
}
|
|
2972
|
-
if (input
|
|
2973
|
-
const memberEntries = se_ResourceList(input
|
|
2974
|
-
if (input
|
|
2972
|
+
if (input[_OKA] != null) {
|
|
2973
|
+
const memberEntries = se_ResourceList(input[_OKA], context);
|
|
2974
|
+
if (input[_OKA]?.length === 0) {
|
|
2975
2975
|
entries.OKActions = [];
|
|
2976
2976
|
}
|
|
2977
2977
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2979,9 +2979,9 @@ const se_PutCompositeAlarmInput = (input, context) => {
|
|
|
2979
2979
|
entries[loc] = value;
|
|
2980
2980
|
});
|
|
2981
2981
|
}
|
|
2982
|
-
if (input
|
|
2983
|
-
const memberEntries = se_TagList(input
|
|
2984
|
-
if (input
|
|
2982
|
+
if (input[_Ta] != null) {
|
|
2983
|
+
const memberEntries = se_TagList(input[_Ta], context);
|
|
2984
|
+
if (input[_Ta]?.length === 0) {
|
|
2985
2985
|
entries.Tags = [];
|
|
2986
2986
|
}
|
|
2987
2987
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -2989,41 +2989,41 @@ const se_PutCompositeAlarmInput = (input, context) => {
|
|
|
2989
2989
|
entries[loc] = value;
|
|
2990
2990
|
});
|
|
2991
2991
|
}
|
|
2992
|
-
if (input
|
|
2993
|
-
entries[
|
|
2992
|
+
if (input[_ASc] != null) {
|
|
2993
|
+
entries[_ASc] = input[_ASc];
|
|
2994
2994
|
}
|
|
2995
|
-
if (input
|
|
2996
|
-
entries[
|
|
2995
|
+
if (input[_ASWP] != null) {
|
|
2996
|
+
entries[_ASWP] = input[_ASWP];
|
|
2997
2997
|
}
|
|
2998
|
-
if (input
|
|
2999
|
-
entries[
|
|
2998
|
+
if (input[_ASEP] != null) {
|
|
2999
|
+
entries[_ASEP] = input[_ASEP];
|
|
3000
3000
|
}
|
|
3001
3001
|
return entries;
|
|
3002
3002
|
};
|
|
3003
3003
|
const se_PutDashboardInput = (input, context) => {
|
|
3004
3004
|
const entries = {};
|
|
3005
|
-
if (input
|
|
3006
|
-
entries[
|
|
3005
|
+
if (input[_DNa] != null) {
|
|
3006
|
+
entries[_DNa] = input[_DNa];
|
|
3007
3007
|
}
|
|
3008
|
-
if (input
|
|
3009
|
-
entries[
|
|
3008
|
+
if (input[_DB] != null) {
|
|
3009
|
+
entries[_DB] = input[_DB];
|
|
3010
3010
|
}
|
|
3011
3011
|
return entries;
|
|
3012
3012
|
};
|
|
3013
3013
|
const se_PutInsightRuleInput = (input, context) => {
|
|
3014
3014
|
const entries = {};
|
|
3015
|
-
if (input
|
|
3016
|
-
entries[
|
|
3015
|
+
if (input[_RNu] != null) {
|
|
3016
|
+
entries[_RNu] = input[_RNu];
|
|
3017
3017
|
}
|
|
3018
|
-
if (input
|
|
3019
|
-
entries[
|
|
3018
|
+
if (input[_RS] != null) {
|
|
3019
|
+
entries[_RS] = input[_RS];
|
|
3020
3020
|
}
|
|
3021
|
-
if (input
|
|
3022
|
-
entries[
|
|
3021
|
+
if (input[_RDu] != null) {
|
|
3022
|
+
entries[_RDu] = input[_RDu];
|
|
3023
3023
|
}
|
|
3024
|
-
if (input
|
|
3025
|
-
const memberEntries = se_TagList(input
|
|
3026
|
-
if (input
|
|
3024
|
+
if (input[_Ta] != null) {
|
|
3025
|
+
const memberEntries = se_TagList(input[_Ta], context);
|
|
3026
|
+
if (input[_Ta]?.length === 0) {
|
|
3027
3027
|
entries.Tags = [];
|
|
3028
3028
|
}
|
|
3029
3029
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3035,9 +3035,9 @@ const se_PutInsightRuleInput = (input, context) => {
|
|
|
3035
3035
|
};
|
|
3036
3036
|
const se_PutManagedInsightRulesInput = (input, context) => {
|
|
3037
3037
|
const entries = {};
|
|
3038
|
-
if (input
|
|
3039
|
-
const memberEntries = se_ManagedRules(input
|
|
3040
|
-
if (input
|
|
3038
|
+
if (input[_MRan] != null) {
|
|
3039
|
+
const memberEntries = se_ManagedRules(input[_MRan], context);
|
|
3040
|
+
if (input[_MRan]?.length === 0) {
|
|
3041
3041
|
entries.ManagedRules = [];
|
|
3042
3042
|
}
|
|
3043
3043
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3049,18 +3049,18 @@ const se_PutManagedInsightRulesInput = (input, context) => {
|
|
|
3049
3049
|
};
|
|
3050
3050
|
const se_PutMetricAlarmInput = (input, context) => {
|
|
3051
3051
|
const entries = {};
|
|
3052
|
-
if (input
|
|
3053
|
-
entries[
|
|
3052
|
+
if (input[_ANl] != null) {
|
|
3053
|
+
entries[_ANl] = input[_ANl];
|
|
3054
3054
|
}
|
|
3055
|
-
if (input
|
|
3056
|
-
entries[
|
|
3055
|
+
if (input[_AD] != null) {
|
|
3056
|
+
entries[_AD] = input[_AD];
|
|
3057
3057
|
}
|
|
3058
|
-
if (input
|
|
3059
|
-
entries[
|
|
3058
|
+
if (input[_AE] != null) {
|
|
3059
|
+
entries[_AE] = input[_AE];
|
|
3060
3060
|
}
|
|
3061
|
-
if (input
|
|
3062
|
-
const memberEntries = se_ResourceList(input
|
|
3063
|
-
if (input
|
|
3061
|
+
if (input[_OKA] != null) {
|
|
3062
|
+
const memberEntries = se_ResourceList(input[_OKA], context);
|
|
3063
|
+
if (input[_OKA]?.length === 0) {
|
|
3064
3064
|
entries.OKActions = [];
|
|
3065
3065
|
}
|
|
3066
3066
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3068,9 +3068,9 @@ const se_PutMetricAlarmInput = (input, context) => {
|
|
|
3068
3068
|
entries[loc] = value;
|
|
3069
3069
|
});
|
|
3070
3070
|
}
|
|
3071
|
-
if (input
|
|
3072
|
-
const memberEntries = se_ResourceList(input
|
|
3073
|
-
if (input
|
|
3071
|
+
if (input[_AA] != null) {
|
|
3072
|
+
const memberEntries = se_ResourceList(input[_AA], context);
|
|
3073
|
+
if (input[_AA]?.length === 0) {
|
|
3074
3074
|
entries.AlarmActions = [];
|
|
3075
3075
|
}
|
|
3076
3076
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3078,9 +3078,9 @@ const se_PutMetricAlarmInput = (input, context) => {
|
|
|
3078
3078
|
entries[loc] = value;
|
|
3079
3079
|
});
|
|
3080
3080
|
}
|
|
3081
|
-
if (input
|
|
3082
|
-
const memberEntries = se_ResourceList(input
|
|
3083
|
-
if (input
|
|
3081
|
+
if (input[_IDA] != null) {
|
|
3082
|
+
const memberEntries = se_ResourceList(input[_IDA], context);
|
|
3083
|
+
if (input[_IDA]?.length === 0) {
|
|
3084
3084
|
entries.InsufficientDataActions = [];
|
|
3085
3085
|
}
|
|
3086
3086
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3088,21 +3088,21 @@ const se_PutMetricAlarmInput = (input, context) => {
|
|
|
3088
3088
|
entries[loc] = value;
|
|
3089
3089
|
});
|
|
3090
3090
|
}
|
|
3091
|
-
if (input
|
|
3092
|
-
entries[
|
|
3091
|
+
if (input[_MN] != null) {
|
|
3092
|
+
entries[_MN] = input[_MN];
|
|
3093
3093
|
}
|
|
3094
|
-
if (input
|
|
3095
|
-
entries[
|
|
3094
|
+
if (input[_N] != null) {
|
|
3095
|
+
entries[_N] = input[_N];
|
|
3096
3096
|
}
|
|
3097
|
-
if (input
|
|
3098
|
-
entries[
|
|
3097
|
+
if (input[_St] != null) {
|
|
3098
|
+
entries[_St] = input[_St];
|
|
3099
3099
|
}
|
|
3100
|
-
if (input
|
|
3101
|
-
entries[
|
|
3100
|
+
if (input[_ES] != null) {
|
|
3101
|
+
entries[_ES] = input[_ES];
|
|
3102
3102
|
}
|
|
3103
|
-
if (input
|
|
3104
|
-
const memberEntries = se_Dimensions(input
|
|
3105
|
-
if (input
|
|
3103
|
+
if (input[_D] != null) {
|
|
3104
|
+
const memberEntries = se_Dimensions(input[_D], context);
|
|
3105
|
+
if (input[_D]?.length === 0) {
|
|
3106
3106
|
entries.Dimensions = [];
|
|
3107
3107
|
}
|
|
3108
3108
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3110,33 +3110,33 @@ const se_PutMetricAlarmInput = (input, context) => {
|
|
|
3110
3110
|
entries[loc] = value;
|
|
3111
3111
|
});
|
|
3112
3112
|
}
|
|
3113
|
-
if (input
|
|
3114
|
-
entries[
|
|
3113
|
+
if (input[_P] != null) {
|
|
3114
|
+
entries[_P] = input[_P];
|
|
3115
3115
|
}
|
|
3116
|
-
if (input
|
|
3117
|
-
entries[
|
|
3116
|
+
if (input[_U] != null) {
|
|
3117
|
+
entries[_U] = input[_U];
|
|
3118
3118
|
}
|
|
3119
|
-
if (input
|
|
3120
|
-
entries[
|
|
3119
|
+
if (input[_EP] != null) {
|
|
3120
|
+
entries[_EP] = input[_EP];
|
|
3121
3121
|
}
|
|
3122
|
-
if (input
|
|
3123
|
-
entries[
|
|
3122
|
+
if (input[_DTA] != null) {
|
|
3123
|
+
entries[_DTA] = input[_DTA];
|
|
3124
3124
|
}
|
|
3125
|
-
if (input
|
|
3126
|
-
entries[
|
|
3125
|
+
if (input[_Th] != null) {
|
|
3126
|
+
entries[_Th] = __serializeFloat(input[_Th]);
|
|
3127
3127
|
}
|
|
3128
|
-
if (input
|
|
3129
|
-
entries[
|
|
3128
|
+
if (input[_CO] != null) {
|
|
3129
|
+
entries[_CO] = input[_CO];
|
|
3130
3130
|
}
|
|
3131
|
-
if (input
|
|
3132
|
-
entries[
|
|
3131
|
+
if (input[_TMD] != null) {
|
|
3132
|
+
entries[_TMD] = input[_TMD];
|
|
3133
3133
|
}
|
|
3134
|
-
if (input
|
|
3135
|
-
entries[
|
|
3134
|
+
if (input[_ELSCP] != null) {
|
|
3135
|
+
entries[_ELSCP] = input[_ELSCP];
|
|
3136
3136
|
}
|
|
3137
|
-
if (input
|
|
3138
|
-
const memberEntries = se_MetricDataQueries(input
|
|
3139
|
-
if (input
|
|
3137
|
+
if (input[_M] != null) {
|
|
3138
|
+
const memberEntries = se_MetricDataQueries(input[_M], context);
|
|
3139
|
+
if (input[_M]?.length === 0) {
|
|
3140
3140
|
entries.Metrics = [];
|
|
3141
3141
|
}
|
|
3142
3142
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3144,9 +3144,9 @@ const se_PutMetricAlarmInput = (input, context) => {
|
|
|
3144
3144
|
entries[loc] = value;
|
|
3145
3145
|
});
|
|
3146
3146
|
}
|
|
3147
|
-
if (input
|
|
3148
|
-
const memberEntries = se_TagList(input
|
|
3149
|
-
if (input
|
|
3147
|
+
if (input[_Ta] != null) {
|
|
3148
|
+
const memberEntries = se_TagList(input[_Ta], context);
|
|
3149
|
+
if (input[_Ta]?.length === 0) {
|
|
3150
3150
|
entries.Tags = [];
|
|
3151
3151
|
}
|
|
3152
3152
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3154,19 +3154,19 @@ const se_PutMetricAlarmInput = (input, context) => {
|
|
|
3154
3154
|
entries[loc] = value;
|
|
3155
3155
|
});
|
|
3156
3156
|
}
|
|
3157
|
-
if (input
|
|
3158
|
-
entries[
|
|
3157
|
+
if (input[_TMI] != null) {
|
|
3158
|
+
entries[_TMI] = input[_TMI];
|
|
3159
3159
|
}
|
|
3160
3160
|
return entries;
|
|
3161
3161
|
};
|
|
3162
3162
|
const se_PutMetricDataInput = (input, context) => {
|
|
3163
3163
|
const entries = {};
|
|
3164
|
-
if (input
|
|
3165
|
-
entries[
|
|
3164
|
+
if (input[_N] != null) {
|
|
3165
|
+
entries[_N] = input[_N];
|
|
3166
3166
|
}
|
|
3167
|
-
if (input
|
|
3168
|
-
const memberEntries = se_MetricData(input
|
|
3169
|
-
if (input
|
|
3167
|
+
if (input[_MDe] != null) {
|
|
3168
|
+
const memberEntries = se_MetricData(input[_MDe], context);
|
|
3169
|
+
if (input[_MDe]?.length === 0) {
|
|
3170
3170
|
entries.MetricData = [];
|
|
3171
3171
|
}
|
|
3172
3172
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3178,12 +3178,12 @@ const se_PutMetricDataInput = (input, context) => {
|
|
|
3178
3178
|
};
|
|
3179
3179
|
const se_PutMetricStreamInput = (input, context) => {
|
|
3180
3180
|
const entries = {};
|
|
3181
|
-
if (input
|
|
3182
|
-
entries[
|
|
3181
|
+
if (input[_Na] != null) {
|
|
3182
|
+
entries[_Na] = input[_Na];
|
|
3183
3183
|
}
|
|
3184
|
-
if (input
|
|
3185
|
-
const memberEntries = se_MetricStreamFilters(input
|
|
3186
|
-
if (input
|
|
3184
|
+
if (input[_IF] != null) {
|
|
3185
|
+
const memberEntries = se_MetricStreamFilters(input[_IF], context);
|
|
3186
|
+
if (input[_IF]?.length === 0) {
|
|
3187
3187
|
entries.IncludeFilters = [];
|
|
3188
3188
|
}
|
|
3189
3189
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3191,9 +3191,9 @@ const se_PutMetricStreamInput = (input, context) => {
|
|
|
3191
3191
|
entries[loc] = value;
|
|
3192
3192
|
});
|
|
3193
3193
|
}
|
|
3194
|
-
if (input
|
|
3195
|
-
const memberEntries = se_MetricStreamFilters(input
|
|
3196
|
-
if (input
|
|
3194
|
+
if (input[_EF] != null) {
|
|
3195
|
+
const memberEntries = se_MetricStreamFilters(input[_EF], context);
|
|
3196
|
+
if (input[_EF]?.length === 0) {
|
|
3197
3197
|
entries.ExcludeFilters = [];
|
|
3198
3198
|
}
|
|
3199
3199
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3201,18 +3201,18 @@ const se_PutMetricStreamInput = (input, context) => {
|
|
|
3201
3201
|
entries[loc] = value;
|
|
3202
3202
|
});
|
|
3203
3203
|
}
|
|
3204
|
-
if (input
|
|
3205
|
-
entries[
|
|
3204
|
+
if (input[_FA] != null) {
|
|
3205
|
+
entries[_FA] = input[_FA];
|
|
3206
3206
|
}
|
|
3207
|
-
if (input
|
|
3208
|
-
entries[
|
|
3207
|
+
if (input[_RAo] != null) {
|
|
3208
|
+
entries[_RAo] = input[_RAo];
|
|
3209
3209
|
}
|
|
3210
|
-
if (input
|
|
3211
|
-
entries[
|
|
3210
|
+
if (input[_OF] != null) {
|
|
3211
|
+
entries[_OF] = input[_OF];
|
|
3212
3212
|
}
|
|
3213
|
-
if (input
|
|
3214
|
-
const memberEntries = se_TagList(input
|
|
3215
|
-
if (input
|
|
3213
|
+
if (input[_Ta] != null) {
|
|
3214
|
+
const memberEntries = se_TagList(input[_Ta], context);
|
|
3215
|
+
if (input[_Ta]?.length === 0) {
|
|
3216
3216
|
entries.Tags = [];
|
|
3217
3217
|
}
|
|
3218
3218
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3220,9 +3220,9 @@ const se_PutMetricStreamInput = (input, context) => {
|
|
|
3220
3220
|
entries[loc] = value;
|
|
3221
3221
|
});
|
|
3222
3222
|
}
|
|
3223
|
-
if (input
|
|
3224
|
-
const memberEntries = se_MetricStreamStatisticsConfigurations(input
|
|
3225
|
-
if (input
|
|
3223
|
+
if (input[_SC] != null) {
|
|
3224
|
+
const memberEntries = se_MetricStreamStatisticsConfigurations(input[_SC], context);
|
|
3225
|
+
if (input[_SC]?.length === 0) {
|
|
3226
3226
|
entries.StatisticsConfigurations = [];
|
|
3227
3227
|
}
|
|
3228
3228
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3230,18 +3230,18 @@ const se_PutMetricStreamInput = (input, context) => {
|
|
|
3230
3230
|
entries[loc] = value;
|
|
3231
3231
|
});
|
|
3232
3232
|
}
|
|
3233
|
-
if (input
|
|
3234
|
-
entries[
|
|
3233
|
+
if (input[_ILAM] != null) {
|
|
3234
|
+
entries[_ILAM] = input[_ILAM];
|
|
3235
3235
|
}
|
|
3236
3236
|
return entries;
|
|
3237
3237
|
};
|
|
3238
3238
|
const se_Range = (input, context) => {
|
|
3239
3239
|
const entries = {};
|
|
3240
|
-
if (input
|
|
3241
|
-
entries[
|
|
3240
|
+
if (input[_ST] != null) {
|
|
3241
|
+
entries[_ST] = input[_ST].toISOString().split(".")[0] + "Z";
|
|
3242
3242
|
}
|
|
3243
|
-
if (input
|
|
3244
|
-
entries[
|
|
3243
|
+
if (input[_ET] != null) {
|
|
3244
|
+
entries[_ET] = input[_ET].toISOString().split(".")[0] + "Z";
|
|
3245
3245
|
}
|
|
3246
3246
|
return entries;
|
|
3247
3247
|
};
|
|
@@ -3259,31 +3259,31 @@ const se_ResourceList = (input, context) => {
|
|
|
3259
3259
|
};
|
|
3260
3260
|
const se_SetAlarmStateInput = (input, context) => {
|
|
3261
3261
|
const entries = {};
|
|
3262
|
-
if (input
|
|
3263
|
-
entries[
|
|
3262
|
+
if (input[_ANl] != null) {
|
|
3263
|
+
entries[_ANl] = input[_ANl];
|
|
3264
3264
|
}
|
|
3265
|
-
if (input
|
|
3266
|
-
entries[
|
|
3265
|
+
if (input[_SV] != null) {
|
|
3266
|
+
entries[_SV] = input[_SV];
|
|
3267
3267
|
}
|
|
3268
|
-
if (input
|
|
3269
|
-
entries[
|
|
3268
|
+
if (input[_SRt] != null) {
|
|
3269
|
+
entries[_SRt] = input[_SRt];
|
|
3270
3270
|
}
|
|
3271
|
-
if (input
|
|
3272
|
-
entries[
|
|
3271
|
+
if (input[_SRD] != null) {
|
|
3272
|
+
entries[_SRD] = input[_SRD];
|
|
3273
3273
|
}
|
|
3274
3274
|
return entries;
|
|
3275
3275
|
};
|
|
3276
3276
|
const se_SingleMetricAnomalyDetector = (input, context) => {
|
|
3277
3277
|
const entries = {};
|
|
3278
|
-
if (input
|
|
3279
|
-
entries[
|
|
3278
|
+
if (input[_N] != null) {
|
|
3279
|
+
entries[_N] = input[_N];
|
|
3280
3280
|
}
|
|
3281
|
-
if (input
|
|
3282
|
-
entries[
|
|
3281
|
+
if (input[_MN] != null) {
|
|
3282
|
+
entries[_MN] = input[_MN];
|
|
3283
3283
|
}
|
|
3284
|
-
if (input
|
|
3285
|
-
const memberEntries = se_Dimensions(input
|
|
3286
|
-
if (input
|
|
3284
|
+
if (input[_D] != null) {
|
|
3285
|
+
const memberEntries = se_Dimensions(input[_D], context);
|
|
3286
|
+
if (input[_D]?.length === 0) {
|
|
3287
3287
|
entries.Dimensions = [];
|
|
3288
3288
|
}
|
|
3289
3289
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3291,16 +3291,16 @@ const se_SingleMetricAnomalyDetector = (input, context) => {
|
|
|
3291
3291
|
entries[loc] = value;
|
|
3292
3292
|
});
|
|
3293
3293
|
}
|
|
3294
|
-
if (input
|
|
3295
|
-
entries[
|
|
3294
|
+
if (input[_S] != null) {
|
|
3295
|
+
entries[_S] = input[_S];
|
|
3296
3296
|
}
|
|
3297
3297
|
return entries;
|
|
3298
3298
|
};
|
|
3299
3299
|
const se_StartMetricStreamsInput = (input, context) => {
|
|
3300
3300
|
const entries = {};
|
|
3301
|
-
if (input
|
|
3302
|
-
const memberEntries = se_MetricStreamNames(input
|
|
3303
|
-
if (input
|
|
3301
|
+
if (input[_Nam] != null) {
|
|
3302
|
+
const memberEntries = se_MetricStreamNames(input[_Nam], context);
|
|
3303
|
+
if (input[_Nam]?.length === 0) {
|
|
3304
3304
|
entries.Names = [];
|
|
3305
3305
|
}
|
|
3306
3306
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3324,25 +3324,25 @@ const se_Statistics = (input, context) => {
|
|
|
3324
3324
|
};
|
|
3325
3325
|
const se_StatisticSet = (input, context) => {
|
|
3326
3326
|
const entries = {};
|
|
3327
|
-
if (input
|
|
3328
|
-
entries[
|
|
3327
|
+
if (input[_SCa] != null) {
|
|
3328
|
+
entries[_SCa] = __serializeFloat(input[_SCa]);
|
|
3329
3329
|
}
|
|
3330
|
-
if (input
|
|
3331
|
-
entries[
|
|
3330
|
+
if (input[_Su] != null) {
|
|
3331
|
+
entries[_Su] = __serializeFloat(input[_Su]);
|
|
3332
3332
|
}
|
|
3333
|
-
if (input
|
|
3334
|
-
entries[
|
|
3333
|
+
if (input[_Mi] != null) {
|
|
3334
|
+
entries[_Mi] = __serializeFloat(input[_Mi]);
|
|
3335
3335
|
}
|
|
3336
|
-
if (input
|
|
3337
|
-
entries[
|
|
3336
|
+
if (input[_Ma] != null) {
|
|
3337
|
+
entries[_Ma] = __serializeFloat(input[_Ma]);
|
|
3338
3338
|
}
|
|
3339
3339
|
return entries;
|
|
3340
3340
|
};
|
|
3341
3341
|
const se_StopMetricStreamsInput = (input, context) => {
|
|
3342
3342
|
const entries = {};
|
|
3343
|
-
if (input
|
|
3344
|
-
const memberEntries = se_MetricStreamNames(input
|
|
3345
|
-
if (input
|
|
3343
|
+
if (input[_Nam] != null) {
|
|
3344
|
+
const memberEntries = se_MetricStreamNames(input[_Nam], context);
|
|
3345
|
+
if (input[_Nam]?.length === 0) {
|
|
3346
3346
|
entries.Names = [];
|
|
3347
3347
|
}
|
|
3348
3348
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3354,11 +3354,11 @@ const se_StopMetricStreamsInput = (input, context) => {
|
|
|
3354
3354
|
};
|
|
3355
3355
|
const se_Tag = (input, context) => {
|
|
3356
3356
|
const entries = {};
|
|
3357
|
-
if (input
|
|
3358
|
-
entries[
|
|
3357
|
+
if (input[_K] != null) {
|
|
3358
|
+
entries[_K] = input[_K];
|
|
3359
3359
|
}
|
|
3360
|
-
if (input
|
|
3361
|
-
entries[
|
|
3360
|
+
if (input[_Va] != null) {
|
|
3361
|
+
entries[_Va] = input[_Va];
|
|
3362
3362
|
}
|
|
3363
3363
|
return entries;
|
|
3364
3364
|
};
|
|
@@ -3391,12 +3391,12 @@ const se_TagList = (input, context) => {
|
|
|
3391
3391
|
};
|
|
3392
3392
|
const se_TagResourceInput = (input, context) => {
|
|
3393
3393
|
const entries = {};
|
|
3394
|
-
if (input
|
|
3395
|
-
entries[
|
|
3394
|
+
if (input[_RARN] != null) {
|
|
3395
|
+
entries[_RARN] = input[_RARN];
|
|
3396
3396
|
}
|
|
3397
|
-
if (input
|
|
3398
|
-
const memberEntries = se_TagList(input
|
|
3399
|
-
if (input
|
|
3397
|
+
if (input[_Ta] != null) {
|
|
3398
|
+
const memberEntries = se_TagList(input[_Ta], context);
|
|
3399
|
+
if (input[_Ta]?.length === 0) {
|
|
3400
3400
|
entries.Tags = [];
|
|
3401
3401
|
}
|
|
3402
3402
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3408,12 +3408,12 @@ const se_TagResourceInput = (input, context) => {
|
|
|
3408
3408
|
};
|
|
3409
3409
|
const se_UntagResourceInput = (input, context) => {
|
|
3410
3410
|
const entries = {};
|
|
3411
|
-
if (input
|
|
3412
|
-
entries[
|
|
3411
|
+
if (input[_RARN] != null) {
|
|
3412
|
+
entries[_RARN] = input[_RARN];
|
|
3413
3413
|
}
|
|
3414
|
-
if (input
|
|
3415
|
-
const memberEntries = se_TagKeyList(input
|
|
3416
|
-
if (input
|
|
3414
|
+
if (input[_TK] != null) {
|
|
3415
|
+
const memberEntries = se_TagKeyList(input[_TK], context);
|
|
3416
|
+
if (input[_TK]?.length === 0) {
|
|
3417
3417
|
entries.TagKeys = [];
|
|
3418
3418
|
}
|
|
3419
3419
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
@@ -3437,23 +3437,23 @@ const se_Values = (input, context) => {
|
|
|
3437
3437
|
};
|
|
3438
3438
|
const de_AlarmHistoryItem = (output, context) => {
|
|
3439
3439
|
const contents = {};
|
|
3440
|
-
if (output[
|
|
3441
|
-
contents
|
|
3440
|
+
if (output[_ANl] != null) {
|
|
3441
|
+
contents[_ANl] = __expectString(output[_ANl]);
|
|
3442
3442
|
}
|
|
3443
|
-
if (output[
|
|
3444
|
-
contents
|
|
3443
|
+
if (output[_ATl] != null) {
|
|
3444
|
+
contents[_ATl] = __expectString(output[_ATl]);
|
|
3445
3445
|
}
|
|
3446
|
-
if (output[
|
|
3447
|
-
contents
|
|
3446
|
+
if (output[_Ti] != null) {
|
|
3447
|
+
contents[_Ti] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_Ti]));
|
|
3448
3448
|
}
|
|
3449
|
-
if (output[
|
|
3450
|
-
contents
|
|
3449
|
+
if (output[_HIT] != null) {
|
|
3450
|
+
contents[_HIT] = __expectString(output[_HIT]);
|
|
3451
3451
|
}
|
|
3452
|
-
if (output[
|
|
3453
|
-
contents
|
|
3452
|
+
if (output[_HS] != null) {
|
|
3453
|
+
contents[_HS] = __expectString(output[_HS]);
|
|
3454
3454
|
}
|
|
3455
|
-
if (output[
|
|
3456
|
-
contents
|
|
3455
|
+
if (output[_HD] != null) {
|
|
3456
|
+
contents[_HD] = __expectString(output[_HD]);
|
|
3457
3457
|
}
|
|
3458
3458
|
return contents;
|
|
3459
3459
|
};
|
|
@@ -3466,45 +3466,45 @@ const de_AlarmHistoryItems = (output, context) => {
|
|
|
3466
3466
|
};
|
|
3467
3467
|
const de_AnomalyDetector = (output, context) => {
|
|
3468
3468
|
const contents = {};
|
|
3469
|
-
if (output[
|
|
3470
|
-
contents
|
|
3469
|
+
if (output[_N] != null) {
|
|
3470
|
+
contents[_N] = __expectString(output[_N]);
|
|
3471
3471
|
}
|
|
3472
|
-
if (output[
|
|
3473
|
-
contents
|
|
3472
|
+
if (output[_MN] != null) {
|
|
3473
|
+
contents[_MN] = __expectString(output[_MN]);
|
|
3474
3474
|
}
|
|
3475
3475
|
if (output.Dimensions === "") {
|
|
3476
|
-
contents
|
|
3476
|
+
contents[_D] = [];
|
|
3477
3477
|
}
|
|
3478
|
-
else if (output[
|
|
3479
|
-
contents
|
|
3478
|
+
else if (output[_D] != null && output[_D][_m] != null) {
|
|
3479
|
+
contents[_D] = de_Dimensions(__getArrayIfSingleItem(output[_D][_m]), context);
|
|
3480
3480
|
}
|
|
3481
|
-
if (output[
|
|
3482
|
-
contents
|
|
3481
|
+
if (output[_S] != null) {
|
|
3482
|
+
contents[_S] = __expectString(output[_S]);
|
|
3483
3483
|
}
|
|
3484
|
-
if (output[
|
|
3485
|
-
contents
|
|
3484
|
+
if (output[_Co] != null) {
|
|
3485
|
+
contents[_Co] = de_AnomalyDetectorConfiguration(output[_Co], context);
|
|
3486
3486
|
}
|
|
3487
|
-
if (output[
|
|
3488
|
-
contents
|
|
3487
|
+
if (output[_SV] != null) {
|
|
3488
|
+
contents[_SV] = __expectString(output[_SV]);
|
|
3489
3489
|
}
|
|
3490
|
-
if (output[
|
|
3491
|
-
contents
|
|
3490
|
+
if (output[_SMAD] != null) {
|
|
3491
|
+
contents[_SMAD] = de_SingleMetricAnomalyDetector(output[_SMAD], context);
|
|
3492
3492
|
}
|
|
3493
|
-
if (output[
|
|
3494
|
-
contents
|
|
3493
|
+
if (output[_MMAD] != null) {
|
|
3494
|
+
contents[_MMAD] = de_MetricMathAnomalyDetector(output[_MMAD], context);
|
|
3495
3495
|
}
|
|
3496
3496
|
return contents;
|
|
3497
3497
|
};
|
|
3498
3498
|
const de_AnomalyDetectorConfiguration = (output, context) => {
|
|
3499
3499
|
const contents = {};
|
|
3500
3500
|
if (output.ExcludedTimeRanges === "") {
|
|
3501
|
-
contents
|
|
3501
|
+
contents[_ETR] = [];
|
|
3502
3502
|
}
|
|
3503
|
-
else if (output[
|
|
3504
|
-
contents
|
|
3503
|
+
else if (output[_ETR] != null && output[_ETR][_m] != null) {
|
|
3504
|
+
contents[_ETR] = de_AnomalyDetectorExcludedTimeRanges(__getArrayIfSingleItem(output[_ETR][_m]), context);
|
|
3505
3505
|
}
|
|
3506
|
-
if (output[
|
|
3507
|
-
contents
|
|
3506
|
+
if (output[_MT] != null) {
|
|
3507
|
+
contents[_MT] = __expectString(output[_MT]);
|
|
3508
3508
|
}
|
|
3509
3509
|
return contents;
|
|
3510
3510
|
};
|
|
@@ -3531,72 +3531,71 @@ const de_BatchFailures = (output, context) => {
|
|
|
3531
3531
|
};
|
|
3532
3532
|
const de_CompositeAlarm = (output, context) => {
|
|
3533
3533
|
const contents = {};
|
|
3534
|
-
if (output[
|
|
3535
|
-
contents
|
|
3534
|
+
if (output[_AE] != null) {
|
|
3535
|
+
contents[_AE] = __parseBoolean(output[_AE]);
|
|
3536
3536
|
}
|
|
3537
3537
|
if (output.AlarmActions === "") {
|
|
3538
|
-
contents
|
|
3538
|
+
contents[_AA] = [];
|
|
3539
3539
|
}
|
|
3540
|
-
else if (output[
|
|
3541
|
-
contents
|
|
3540
|
+
else if (output[_AA] != null && output[_AA][_m] != null) {
|
|
3541
|
+
contents[_AA] = de_ResourceList(__getArrayIfSingleItem(output[_AA][_m]), context);
|
|
3542
3542
|
}
|
|
3543
|
-
if (output[
|
|
3544
|
-
contents
|
|
3543
|
+
if (output[_AAl] != null) {
|
|
3544
|
+
contents[_AAl] = __expectString(output[_AAl]);
|
|
3545
3545
|
}
|
|
3546
|
-
if (output[
|
|
3547
|
-
contents
|
|
3546
|
+
if (output[_ACUT] != null) {
|
|
3547
|
+
contents[_ACUT] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_ACUT]));
|
|
3548
3548
|
}
|
|
3549
|
-
if (output[
|
|
3550
|
-
contents
|
|
3549
|
+
if (output[_AD] != null) {
|
|
3550
|
+
contents[_AD] = __expectString(output[_AD]);
|
|
3551
3551
|
}
|
|
3552
|
-
if (output[
|
|
3553
|
-
contents
|
|
3552
|
+
if (output[_ANl] != null) {
|
|
3553
|
+
contents[_ANl] = __expectString(output[_ANl]);
|
|
3554
3554
|
}
|
|
3555
|
-
if (output[
|
|
3556
|
-
contents
|
|
3555
|
+
if (output[_AR] != null) {
|
|
3556
|
+
contents[_AR] = __expectString(output[_AR]);
|
|
3557
3557
|
}
|
|
3558
3558
|
if (output.InsufficientDataActions === "") {
|
|
3559
|
-
contents
|
|
3559
|
+
contents[_IDA] = [];
|
|
3560
3560
|
}
|
|
3561
|
-
else if (output[
|
|
3562
|
-
output[
|
|
3563
|
-
contents.InsufficientDataActions = de_ResourceList(__getArrayIfSingleItem(output["InsufficientDataActions"]["member"]), context);
|
|
3561
|
+
else if (output[_IDA] != null && output[_IDA][_m] != null) {
|
|
3562
|
+
contents[_IDA] = de_ResourceList(__getArrayIfSingleItem(output[_IDA][_m]), context);
|
|
3564
3563
|
}
|
|
3565
3564
|
if (output.OKActions === "") {
|
|
3566
|
-
contents
|
|
3565
|
+
contents[_OKA] = [];
|
|
3567
3566
|
}
|
|
3568
|
-
else if (output[
|
|
3569
|
-
contents
|
|
3567
|
+
else if (output[_OKA] != null && output[_OKA][_m] != null) {
|
|
3568
|
+
contents[_OKA] = de_ResourceList(__getArrayIfSingleItem(output[_OKA][_m]), context);
|
|
3570
3569
|
}
|
|
3571
|
-
if (output[
|
|
3572
|
-
contents
|
|
3570
|
+
if (output[_SRt] != null) {
|
|
3571
|
+
contents[_SRt] = __expectString(output[_SRt]);
|
|
3573
3572
|
}
|
|
3574
|
-
if (output[
|
|
3575
|
-
contents
|
|
3573
|
+
if (output[_SRD] != null) {
|
|
3574
|
+
contents[_SRD] = __expectString(output[_SRD]);
|
|
3576
3575
|
}
|
|
3577
|
-
if (output[
|
|
3578
|
-
contents
|
|
3576
|
+
if (output[_SUT] != null) {
|
|
3577
|
+
contents[_SUT] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_SUT]));
|
|
3579
3578
|
}
|
|
3580
|
-
if (output[
|
|
3581
|
-
contents
|
|
3579
|
+
if (output[_SV] != null) {
|
|
3580
|
+
contents[_SV] = __expectString(output[_SV]);
|
|
3582
3581
|
}
|
|
3583
|
-
if (output[
|
|
3584
|
-
contents
|
|
3582
|
+
if (output[_STT] != null) {
|
|
3583
|
+
contents[_STT] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_STT]));
|
|
3585
3584
|
}
|
|
3586
|
-
if (output[
|
|
3587
|
-
contents
|
|
3585
|
+
if (output[_ASB] != null) {
|
|
3586
|
+
contents[_ASB] = __expectString(output[_ASB]);
|
|
3588
3587
|
}
|
|
3589
|
-
if (output[
|
|
3590
|
-
contents
|
|
3588
|
+
if (output[_ASR] != null) {
|
|
3589
|
+
contents[_ASR] = __expectString(output[_ASR]);
|
|
3591
3590
|
}
|
|
3592
|
-
if (output[
|
|
3593
|
-
contents
|
|
3591
|
+
if (output[_ASc] != null) {
|
|
3592
|
+
contents[_ASc] = __expectString(output[_ASc]);
|
|
3594
3593
|
}
|
|
3595
|
-
if (output[
|
|
3596
|
-
contents
|
|
3594
|
+
if (output[_ASWP] != null) {
|
|
3595
|
+
contents[_ASWP] = __strictParseInt32(output[_ASWP]);
|
|
3597
3596
|
}
|
|
3598
|
-
if (output[
|
|
3599
|
-
contents
|
|
3597
|
+
if (output[_ASEP] != null) {
|
|
3598
|
+
contents[_ASEP] = __strictParseInt32(output[_ASEP]);
|
|
3600
3599
|
}
|
|
3601
3600
|
return contents;
|
|
3602
3601
|
};
|
|
@@ -3609,8 +3608,8 @@ const de_CompositeAlarms = (output, context) => {
|
|
|
3609
3608
|
};
|
|
3610
3609
|
const de_ConcurrentModificationException = (output, context) => {
|
|
3611
3610
|
const contents = {};
|
|
3612
|
-
if (output[
|
|
3613
|
-
contents
|
|
3611
|
+
if (output[_Mes] != null) {
|
|
3612
|
+
contents[_Mes] = __expectString(output[_Mes]);
|
|
3614
3613
|
}
|
|
3615
3614
|
return contents;
|
|
3616
3615
|
};
|
|
@@ -3623,48 +3622,47 @@ const de_DashboardEntries = (output, context) => {
|
|
|
3623
3622
|
};
|
|
3624
3623
|
const de_DashboardEntry = (output, context) => {
|
|
3625
3624
|
const contents = {};
|
|
3626
|
-
if (output[
|
|
3627
|
-
contents
|
|
3625
|
+
if (output[_DNa] != null) {
|
|
3626
|
+
contents[_DNa] = __expectString(output[_DNa]);
|
|
3628
3627
|
}
|
|
3629
|
-
if (output[
|
|
3630
|
-
contents
|
|
3628
|
+
if (output[_DAa] != null) {
|
|
3629
|
+
contents[_DAa] = __expectString(output[_DAa]);
|
|
3631
3630
|
}
|
|
3632
|
-
if (output[
|
|
3633
|
-
contents
|
|
3631
|
+
if (output[_LMa] != null) {
|
|
3632
|
+
contents[_LMa] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_LMa]));
|
|
3634
3633
|
}
|
|
3635
|
-
if (output[
|
|
3636
|
-
contents
|
|
3634
|
+
if (output[_Si] != null) {
|
|
3635
|
+
contents[_Si] = __strictParseLong(output[_Si]);
|
|
3637
3636
|
}
|
|
3638
3637
|
return contents;
|
|
3639
3638
|
};
|
|
3640
3639
|
const de_DashboardInvalidInputError = (output, context) => {
|
|
3641
3640
|
const contents = {};
|
|
3642
|
-
if (output[
|
|
3643
|
-
contents
|
|
3641
|
+
if (output[_me] != null) {
|
|
3642
|
+
contents[_me] = __expectString(output[_me]);
|
|
3644
3643
|
}
|
|
3645
3644
|
if (output.dashboardValidationMessages === "") {
|
|
3646
|
-
contents
|
|
3645
|
+
contents[_dVM] = [];
|
|
3647
3646
|
}
|
|
3648
|
-
else if (output[
|
|
3649
|
-
output[
|
|
3650
|
-
contents.dashboardValidationMessages = de_DashboardValidationMessages(__getArrayIfSingleItem(output["dashboardValidationMessages"]["member"]), context);
|
|
3647
|
+
else if (output[_dVM] != null && output[_dVM][_m] != null) {
|
|
3648
|
+
contents[_dVM] = de_DashboardValidationMessages(__getArrayIfSingleItem(output[_dVM][_m]), context);
|
|
3651
3649
|
}
|
|
3652
3650
|
return contents;
|
|
3653
3651
|
};
|
|
3654
3652
|
const de_DashboardNotFoundError = (output, context) => {
|
|
3655
3653
|
const contents = {};
|
|
3656
|
-
if (output[
|
|
3657
|
-
contents
|
|
3654
|
+
if (output[_me] != null) {
|
|
3655
|
+
contents[_me] = __expectString(output[_me]);
|
|
3658
3656
|
}
|
|
3659
3657
|
return contents;
|
|
3660
3658
|
};
|
|
3661
3659
|
const de_DashboardValidationMessage = (output, context) => {
|
|
3662
3660
|
const contents = {};
|
|
3663
|
-
if (output[
|
|
3664
|
-
contents
|
|
3661
|
+
if (output[_DP] != null) {
|
|
3662
|
+
contents[_DP] = __expectString(output[_DP]);
|
|
3665
3663
|
}
|
|
3666
|
-
if (output[
|
|
3667
|
-
contents
|
|
3664
|
+
if (output[_Mes] != null) {
|
|
3665
|
+
contents[_Mes] = __expectString(output[_Mes]);
|
|
3668
3666
|
}
|
|
3669
3667
|
return contents;
|
|
3670
3668
|
};
|
|
@@ -3677,32 +3675,32 @@ const de_DashboardValidationMessages = (output, context) => {
|
|
|
3677
3675
|
};
|
|
3678
3676
|
const de_Datapoint = (output, context) => {
|
|
3679
3677
|
const contents = {};
|
|
3680
|
-
if (output[
|
|
3681
|
-
contents
|
|
3678
|
+
if (output[_Ti] != null) {
|
|
3679
|
+
contents[_Ti] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_Ti]));
|
|
3682
3680
|
}
|
|
3683
|
-
if (output[
|
|
3684
|
-
contents
|
|
3681
|
+
if (output[_SCa] != null) {
|
|
3682
|
+
contents[_SCa] = __strictParseFloat(output[_SCa]);
|
|
3685
3683
|
}
|
|
3686
|
-
if (output[
|
|
3687
|
-
contents
|
|
3684
|
+
if (output[_Av] != null) {
|
|
3685
|
+
contents[_Av] = __strictParseFloat(output[_Av]);
|
|
3688
3686
|
}
|
|
3689
|
-
if (output[
|
|
3690
|
-
contents
|
|
3687
|
+
if (output[_Su] != null) {
|
|
3688
|
+
contents[_Su] = __strictParseFloat(output[_Su]);
|
|
3691
3689
|
}
|
|
3692
|
-
if (output[
|
|
3693
|
-
contents
|
|
3690
|
+
if (output[_Mi] != null) {
|
|
3691
|
+
contents[_Mi] = __strictParseFloat(output[_Mi]);
|
|
3694
3692
|
}
|
|
3695
|
-
if (output[
|
|
3696
|
-
contents
|
|
3693
|
+
if (output[_Ma] != null) {
|
|
3694
|
+
contents[_Ma] = __strictParseFloat(output[_Ma]);
|
|
3697
3695
|
}
|
|
3698
|
-
if (output[
|
|
3699
|
-
contents
|
|
3696
|
+
if (output[_U] != null) {
|
|
3697
|
+
contents[_U] = __expectString(output[_U]);
|
|
3700
3698
|
}
|
|
3701
3699
|
if (output.ExtendedStatistics === "") {
|
|
3702
|
-
contents
|
|
3700
|
+
contents[_ESx] = {};
|
|
3703
3701
|
}
|
|
3704
|
-
else if (output[
|
|
3705
|
-
contents
|
|
3702
|
+
else if (output[_ESx] != null && output[_ESx][_e] != null) {
|
|
3703
|
+
contents[_ESx] = de_DatapointValueMap(__getArrayIfSingleItem(output[_ESx][_e]), context);
|
|
3706
3704
|
}
|
|
3707
3705
|
return contents;
|
|
3708
3706
|
};
|
|
@@ -3740,10 +3738,10 @@ const de_DeleteDashboardsOutput = (output, context) => {
|
|
|
3740
3738
|
const de_DeleteInsightRulesOutput = (output, context) => {
|
|
3741
3739
|
const contents = {};
|
|
3742
3740
|
if (output.Failures === "") {
|
|
3743
|
-
contents
|
|
3741
|
+
contents[_F] = [];
|
|
3744
3742
|
}
|
|
3745
|
-
else if (output[
|
|
3746
|
-
contents
|
|
3743
|
+
else if (output[_F] != null && output[_F][_m] != null) {
|
|
3744
|
+
contents[_F] = de_BatchFailures(__getArrayIfSingleItem(output[_F][_m]), context);
|
|
3747
3745
|
}
|
|
3748
3746
|
return contents;
|
|
3749
3747
|
};
|
|
@@ -3754,78 +3752,78 @@ const de_DeleteMetricStreamOutput = (output, context) => {
|
|
|
3754
3752
|
const de_DescribeAlarmHistoryOutput = (output, context) => {
|
|
3755
3753
|
const contents = {};
|
|
3756
3754
|
if (output.AlarmHistoryItems === "") {
|
|
3757
|
-
contents
|
|
3755
|
+
contents[_AHI] = [];
|
|
3758
3756
|
}
|
|
3759
|
-
else if (output[
|
|
3760
|
-
contents
|
|
3757
|
+
else if (output[_AHI] != null && output[_AHI][_m] != null) {
|
|
3758
|
+
contents[_AHI] = de_AlarmHistoryItems(__getArrayIfSingleItem(output[_AHI][_m]), context);
|
|
3761
3759
|
}
|
|
3762
|
-
if (output[
|
|
3763
|
-
contents
|
|
3760
|
+
if (output[_NT] != null) {
|
|
3761
|
+
contents[_NT] = __expectString(output[_NT]);
|
|
3764
3762
|
}
|
|
3765
3763
|
return contents;
|
|
3766
3764
|
};
|
|
3767
3765
|
const de_DescribeAlarmsForMetricOutput = (output, context) => {
|
|
3768
3766
|
const contents = {};
|
|
3769
3767
|
if (output.MetricAlarms === "") {
|
|
3770
|
-
contents
|
|
3768
|
+
contents[_MA] = [];
|
|
3771
3769
|
}
|
|
3772
|
-
else if (output[
|
|
3773
|
-
contents
|
|
3770
|
+
else if (output[_MA] != null && output[_MA][_m] != null) {
|
|
3771
|
+
contents[_MA] = de_MetricAlarms(__getArrayIfSingleItem(output[_MA][_m]), context);
|
|
3774
3772
|
}
|
|
3775
3773
|
return contents;
|
|
3776
3774
|
};
|
|
3777
3775
|
const de_DescribeAlarmsOutput = (output, context) => {
|
|
3778
3776
|
const contents = {};
|
|
3779
3777
|
if (output.CompositeAlarms === "") {
|
|
3780
|
-
contents
|
|
3778
|
+
contents[_CA] = [];
|
|
3781
3779
|
}
|
|
3782
|
-
else if (output[
|
|
3783
|
-
contents
|
|
3780
|
+
else if (output[_CA] != null && output[_CA][_m] != null) {
|
|
3781
|
+
contents[_CA] = de_CompositeAlarms(__getArrayIfSingleItem(output[_CA][_m]), context);
|
|
3784
3782
|
}
|
|
3785
3783
|
if (output.MetricAlarms === "") {
|
|
3786
|
-
contents
|
|
3784
|
+
contents[_MA] = [];
|
|
3787
3785
|
}
|
|
3788
|
-
else if (output[
|
|
3789
|
-
contents
|
|
3786
|
+
else if (output[_MA] != null && output[_MA][_m] != null) {
|
|
3787
|
+
contents[_MA] = de_MetricAlarms(__getArrayIfSingleItem(output[_MA][_m]), context);
|
|
3790
3788
|
}
|
|
3791
|
-
if (output[
|
|
3792
|
-
contents
|
|
3789
|
+
if (output[_NT] != null) {
|
|
3790
|
+
contents[_NT] = __expectString(output[_NT]);
|
|
3793
3791
|
}
|
|
3794
3792
|
return contents;
|
|
3795
3793
|
};
|
|
3796
3794
|
const de_DescribeAnomalyDetectorsOutput = (output, context) => {
|
|
3797
3795
|
const contents = {};
|
|
3798
3796
|
if (output.AnomalyDetectors === "") {
|
|
3799
|
-
contents
|
|
3797
|
+
contents[_ADn] = [];
|
|
3800
3798
|
}
|
|
3801
|
-
else if (output[
|
|
3802
|
-
contents
|
|
3799
|
+
else if (output[_ADn] != null && output[_ADn][_m] != null) {
|
|
3800
|
+
contents[_ADn] = de_AnomalyDetectors(__getArrayIfSingleItem(output[_ADn][_m]), context);
|
|
3803
3801
|
}
|
|
3804
|
-
if (output[
|
|
3805
|
-
contents
|
|
3802
|
+
if (output[_NT] != null) {
|
|
3803
|
+
contents[_NT] = __expectString(output[_NT]);
|
|
3806
3804
|
}
|
|
3807
3805
|
return contents;
|
|
3808
3806
|
};
|
|
3809
3807
|
const de_DescribeInsightRulesOutput = (output, context) => {
|
|
3810
3808
|
const contents = {};
|
|
3811
|
-
if (output[
|
|
3812
|
-
contents
|
|
3809
|
+
if (output[_NT] != null) {
|
|
3810
|
+
contents[_NT] = __expectString(output[_NT]);
|
|
3813
3811
|
}
|
|
3814
3812
|
if (output.InsightRules === "") {
|
|
3815
|
-
contents
|
|
3813
|
+
contents[_IR] = [];
|
|
3816
3814
|
}
|
|
3817
|
-
else if (output[
|
|
3818
|
-
contents
|
|
3815
|
+
else if (output[_IR] != null && output[_IR][_m] != null) {
|
|
3816
|
+
contents[_IR] = de_InsightRules(__getArrayIfSingleItem(output[_IR][_m]), context);
|
|
3819
3817
|
}
|
|
3820
3818
|
return contents;
|
|
3821
3819
|
};
|
|
3822
3820
|
const de_Dimension = (output, context) => {
|
|
3823
3821
|
const contents = {};
|
|
3824
|
-
if (output[
|
|
3825
|
-
contents
|
|
3822
|
+
if (output[_Na] != null) {
|
|
3823
|
+
contents[_Na] = __expectString(output[_Na]);
|
|
3826
3824
|
}
|
|
3827
|
-
if (output[
|
|
3828
|
-
contents
|
|
3825
|
+
if (output[_Va] != null) {
|
|
3826
|
+
contents[_Va] = __expectString(output[_Va]);
|
|
3829
3827
|
}
|
|
3830
3828
|
return contents;
|
|
3831
3829
|
};
|
|
@@ -3839,201 +3837,200 @@ const de_Dimensions = (output, context) => {
|
|
|
3839
3837
|
const de_DisableInsightRulesOutput = (output, context) => {
|
|
3840
3838
|
const contents = {};
|
|
3841
3839
|
if (output.Failures === "") {
|
|
3842
|
-
contents
|
|
3840
|
+
contents[_F] = [];
|
|
3843
3841
|
}
|
|
3844
|
-
else if (output[
|
|
3845
|
-
contents
|
|
3842
|
+
else if (output[_F] != null && output[_F][_m] != null) {
|
|
3843
|
+
contents[_F] = de_BatchFailures(__getArrayIfSingleItem(output[_F][_m]), context);
|
|
3846
3844
|
}
|
|
3847
3845
|
return contents;
|
|
3848
3846
|
};
|
|
3849
3847
|
const de_EnableInsightRulesOutput = (output, context) => {
|
|
3850
3848
|
const contents = {};
|
|
3851
3849
|
if (output.Failures === "") {
|
|
3852
|
-
contents
|
|
3850
|
+
contents[_F] = [];
|
|
3853
3851
|
}
|
|
3854
|
-
else if (output[
|
|
3855
|
-
contents
|
|
3852
|
+
else if (output[_F] != null && output[_F][_m] != null) {
|
|
3853
|
+
contents[_F] = de_BatchFailures(__getArrayIfSingleItem(output[_F][_m]), context);
|
|
3856
3854
|
}
|
|
3857
3855
|
return contents;
|
|
3858
3856
|
};
|
|
3859
3857
|
const de_GetDashboardOutput = (output, context) => {
|
|
3860
3858
|
const contents = {};
|
|
3861
|
-
if (output[
|
|
3862
|
-
contents
|
|
3859
|
+
if (output[_DAa] != null) {
|
|
3860
|
+
contents[_DAa] = __expectString(output[_DAa]);
|
|
3863
3861
|
}
|
|
3864
|
-
if (output[
|
|
3865
|
-
contents
|
|
3862
|
+
if (output[_DB] != null) {
|
|
3863
|
+
contents[_DB] = __expectString(output[_DB]);
|
|
3866
3864
|
}
|
|
3867
|
-
if (output[
|
|
3868
|
-
contents
|
|
3865
|
+
if (output[_DNa] != null) {
|
|
3866
|
+
contents[_DNa] = __expectString(output[_DNa]);
|
|
3869
3867
|
}
|
|
3870
3868
|
return contents;
|
|
3871
3869
|
};
|
|
3872
3870
|
const de_GetInsightRuleReportOutput = (output, context) => {
|
|
3873
3871
|
const contents = {};
|
|
3874
3872
|
if (output.KeyLabels === "") {
|
|
3875
|
-
contents
|
|
3873
|
+
contents[_KL] = [];
|
|
3876
3874
|
}
|
|
3877
|
-
else if (output[
|
|
3878
|
-
contents
|
|
3875
|
+
else if (output[_KL] != null && output[_KL][_m] != null) {
|
|
3876
|
+
contents[_KL] = de_InsightRuleContributorKeyLabels(__getArrayIfSingleItem(output[_KL][_m]), context);
|
|
3879
3877
|
}
|
|
3880
|
-
if (output[
|
|
3881
|
-
contents
|
|
3878
|
+
if (output[_ASg] != null) {
|
|
3879
|
+
contents[_ASg] = __expectString(output[_ASg]);
|
|
3882
3880
|
}
|
|
3883
|
-
if (output[
|
|
3884
|
-
contents
|
|
3881
|
+
if (output[_AV] != null) {
|
|
3882
|
+
contents[_AV] = __strictParseFloat(output[_AV]);
|
|
3885
3883
|
}
|
|
3886
|
-
if (output[
|
|
3887
|
-
contents
|
|
3884
|
+
if (output[_AUC] != null) {
|
|
3885
|
+
contents[_AUC] = __strictParseLong(output[_AUC]);
|
|
3888
3886
|
}
|
|
3889
3887
|
if (output.Contributors === "") {
|
|
3890
|
-
contents
|
|
3888
|
+
contents[_Con] = [];
|
|
3891
3889
|
}
|
|
3892
|
-
else if (output[
|
|
3893
|
-
contents
|
|
3890
|
+
else if (output[_Con] != null && output[_Con][_m] != null) {
|
|
3891
|
+
contents[_Con] = de_InsightRuleContributors(__getArrayIfSingleItem(output[_Con][_m]), context);
|
|
3894
3892
|
}
|
|
3895
3893
|
if (output.MetricDatapoints === "") {
|
|
3896
|
-
contents
|
|
3894
|
+
contents[_MDet] = [];
|
|
3897
3895
|
}
|
|
3898
|
-
else if (output[
|
|
3899
|
-
contents
|
|
3896
|
+
else if (output[_MDet] != null && output[_MDet][_m] != null) {
|
|
3897
|
+
contents[_MDet] = de_InsightRuleMetricDatapoints(__getArrayIfSingleItem(output[_MDet][_m]), context);
|
|
3900
3898
|
}
|
|
3901
3899
|
return contents;
|
|
3902
3900
|
};
|
|
3903
3901
|
const de_GetMetricDataOutput = (output, context) => {
|
|
3904
3902
|
const contents = {};
|
|
3905
3903
|
if (output.MetricDataResults === "") {
|
|
3906
|
-
contents
|
|
3904
|
+
contents[_MDR] = [];
|
|
3907
3905
|
}
|
|
3908
|
-
else if (output[
|
|
3909
|
-
contents
|
|
3906
|
+
else if (output[_MDR] != null && output[_MDR][_m] != null) {
|
|
3907
|
+
contents[_MDR] = de_MetricDataResults(__getArrayIfSingleItem(output[_MDR][_m]), context);
|
|
3910
3908
|
}
|
|
3911
|
-
if (output[
|
|
3912
|
-
contents
|
|
3909
|
+
if (output[_NT] != null) {
|
|
3910
|
+
contents[_NT] = __expectString(output[_NT]);
|
|
3913
3911
|
}
|
|
3914
3912
|
if (output.Messages === "") {
|
|
3915
|
-
contents
|
|
3913
|
+
contents[_Mess] = [];
|
|
3916
3914
|
}
|
|
3917
|
-
else if (output[
|
|
3918
|
-
contents
|
|
3915
|
+
else if (output[_Mess] != null && output[_Mess][_m] != null) {
|
|
3916
|
+
contents[_Mess] = de_MetricDataResultMessages(__getArrayIfSingleItem(output[_Mess][_m]), context);
|
|
3919
3917
|
}
|
|
3920
3918
|
return contents;
|
|
3921
3919
|
};
|
|
3922
3920
|
const de_GetMetricStatisticsOutput = (output, context) => {
|
|
3923
3921
|
const contents = {};
|
|
3924
|
-
if (output[
|
|
3925
|
-
contents
|
|
3922
|
+
if (output[_L] != null) {
|
|
3923
|
+
contents[_L] = __expectString(output[_L]);
|
|
3926
3924
|
}
|
|
3927
3925
|
if (output.Datapoints === "") {
|
|
3928
|
-
contents
|
|
3926
|
+
contents[_Da] = [];
|
|
3929
3927
|
}
|
|
3930
|
-
else if (output[
|
|
3931
|
-
contents
|
|
3928
|
+
else if (output[_Da] != null && output[_Da][_m] != null) {
|
|
3929
|
+
contents[_Da] = de_Datapoints(__getArrayIfSingleItem(output[_Da][_m]), context);
|
|
3932
3930
|
}
|
|
3933
3931
|
return contents;
|
|
3934
3932
|
};
|
|
3935
3933
|
const de_GetMetricStreamOutput = (output, context) => {
|
|
3936
3934
|
const contents = {};
|
|
3937
|
-
if (output[
|
|
3938
|
-
contents
|
|
3935
|
+
if (output[_Ar] != null) {
|
|
3936
|
+
contents[_Ar] = __expectString(output[_Ar]);
|
|
3939
3937
|
}
|
|
3940
|
-
if (output[
|
|
3941
|
-
contents
|
|
3938
|
+
if (output[_Na] != null) {
|
|
3939
|
+
contents[_Na] = __expectString(output[_Na]);
|
|
3942
3940
|
}
|
|
3943
3941
|
if (output.IncludeFilters === "") {
|
|
3944
|
-
contents
|
|
3942
|
+
contents[_IF] = [];
|
|
3945
3943
|
}
|
|
3946
|
-
else if (output[
|
|
3947
|
-
contents
|
|
3944
|
+
else if (output[_IF] != null && output[_IF][_m] != null) {
|
|
3945
|
+
contents[_IF] = de_MetricStreamFilters(__getArrayIfSingleItem(output[_IF][_m]), context);
|
|
3948
3946
|
}
|
|
3949
3947
|
if (output.ExcludeFilters === "") {
|
|
3950
|
-
contents
|
|
3948
|
+
contents[_EF] = [];
|
|
3951
3949
|
}
|
|
3952
|
-
else if (output[
|
|
3953
|
-
contents
|
|
3950
|
+
else if (output[_EF] != null && output[_EF][_m] != null) {
|
|
3951
|
+
contents[_EF] = de_MetricStreamFilters(__getArrayIfSingleItem(output[_EF][_m]), context);
|
|
3954
3952
|
}
|
|
3955
|
-
if (output[
|
|
3956
|
-
contents
|
|
3953
|
+
if (output[_FA] != null) {
|
|
3954
|
+
contents[_FA] = __expectString(output[_FA]);
|
|
3957
3955
|
}
|
|
3958
|
-
if (output[
|
|
3959
|
-
contents
|
|
3956
|
+
if (output[_RAo] != null) {
|
|
3957
|
+
contents[_RAo] = __expectString(output[_RAo]);
|
|
3960
3958
|
}
|
|
3961
|
-
if (output[
|
|
3962
|
-
contents
|
|
3959
|
+
if (output[_Stat] != null) {
|
|
3960
|
+
contents[_Stat] = __expectString(output[_Stat]);
|
|
3963
3961
|
}
|
|
3964
|
-
if (output[
|
|
3965
|
-
contents
|
|
3962
|
+
if (output[_CD] != null) {
|
|
3963
|
+
contents[_CD] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_CD]));
|
|
3966
3964
|
}
|
|
3967
|
-
if (output[
|
|
3968
|
-
contents
|
|
3965
|
+
if (output[_LUD] != null) {
|
|
3966
|
+
contents[_LUD] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_LUD]));
|
|
3969
3967
|
}
|
|
3970
|
-
if (output[
|
|
3971
|
-
contents
|
|
3968
|
+
if (output[_OF] != null) {
|
|
3969
|
+
contents[_OF] = __expectString(output[_OF]);
|
|
3972
3970
|
}
|
|
3973
3971
|
if (output.StatisticsConfigurations === "") {
|
|
3974
|
-
contents
|
|
3972
|
+
contents[_SC] = [];
|
|
3975
3973
|
}
|
|
3976
|
-
else if (output[
|
|
3977
|
-
output[
|
|
3978
|
-
contents.StatisticsConfigurations = de_MetricStreamStatisticsConfigurations(__getArrayIfSingleItem(output["StatisticsConfigurations"]["member"]), context);
|
|
3974
|
+
else if (output[_SC] != null && output[_SC][_m] != null) {
|
|
3975
|
+
contents[_SC] = de_MetricStreamStatisticsConfigurations(__getArrayIfSingleItem(output[_SC][_m]), context);
|
|
3979
3976
|
}
|
|
3980
|
-
if (output[
|
|
3981
|
-
contents
|
|
3977
|
+
if (output[_ILAM] != null) {
|
|
3978
|
+
contents[_ILAM] = __parseBoolean(output[_ILAM]);
|
|
3982
3979
|
}
|
|
3983
3980
|
return contents;
|
|
3984
3981
|
};
|
|
3985
3982
|
const de_GetMetricWidgetImageOutput = (output, context) => {
|
|
3986
3983
|
const contents = {};
|
|
3987
|
-
if (output[
|
|
3988
|
-
contents
|
|
3984
|
+
if (output[_MWI] != null) {
|
|
3985
|
+
contents[_MWI] = context.base64Decoder(output[_MWI]);
|
|
3989
3986
|
}
|
|
3990
3987
|
return contents;
|
|
3991
3988
|
};
|
|
3992
3989
|
const de_InsightRule = (output, context) => {
|
|
3993
3990
|
const contents = {};
|
|
3994
|
-
if (output[
|
|
3995
|
-
contents
|
|
3991
|
+
if (output[_Na] != null) {
|
|
3992
|
+
contents[_Na] = __expectString(output[_Na]);
|
|
3996
3993
|
}
|
|
3997
|
-
if (output[
|
|
3998
|
-
contents
|
|
3994
|
+
if (output[_Stat] != null) {
|
|
3995
|
+
contents[_Stat] = __expectString(output[_Stat]);
|
|
3999
3996
|
}
|
|
4000
|
-
if (output[
|
|
4001
|
-
contents
|
|
3997
|
+
if (output[_Sc] != null) {
|
|
3998
|
+
contents[_Sc] = __expectString(output[_Sc]);
|
|
4002
3999
|
}
|
|
4003
|
-
if (output[
|
|
4004
|
-
contents
|
|
4000
|
+
if (output[_De] != null) {
|
|
4001
|
+
contents[_De] = __expectString(output[_De]);
|
|
4005
4002
|
}
|
|
4006
|
-
if (output[
|
|
4007
|
-
contents
|
|
4003
|
+
if (output[_MRana] != null) {
|
|
4004
|
+
contents[_MRana] = __parseBoolean(output[_MRana]);
|
|
4008
4005
|
}
|
|
4009
4006
|
return contents;
|
|
4010
4007
|
};
|
|
4011
4008
|
const de_InsightRuleContributor = (output, context) => {
|
|
4012
4009
|
const contents = {};
|
|
4013
4010
|
if (output.Keys === "") {
|
|
4014
|
-
contents
|
|
4011
|
+
contents[_Ke] = [];
|
|
4015
4012
|
}
|
|
4016
|
-
else if (output[
|
|
4017
|
-
contents
|
|
4013
|
+
else if (output[_Ke] != null && output[_Ke][_m] != null) {
|
|
4014
|
+
contents[_Ke] = de_InsightRuleContributorKeys(__getArrayIfSingleItem(output[_Ke][_m]), context);
|
|
4018
4015
|
}
|
|
4019
|
-
if (output[
|
|
4020
|
-
contents
|
|
4016
|
+
if (output[_AAV] != null) {
|
|
4017
|
+
contents[_AAV] = __strictParseFloat(output[_AAV]);
|
|
4021
4018
|
}
|
|
4022
4019
|
if (output.Datapoints === "") {
|
|
4023
|
-
contents
|
|
4020
|
+
contents[_Da] = [];
|
|
4024
4021
|
}
|
|
4025
|
-
else if (output[
|
|
4026
|
-
contents
|
|
4022
|
+
else if (output[_Da] != null && output[_Da][_m] != null) {
|
|
4023
|
+
contents[_Da] = de_InsightRuleContributorDatapoints(__getArrayIfSingleItem(output[_Da][_m]), context);
|
|
4027
4024
|
}
|
|
4028
4025
|
return contents;
|
|
4029
4026
|
};
|
|
4030
4027
|
const de_InsightRuleContributorDatapoint = (output, context) => {
|
|
4031
4028
|
const contents = {};
|
|
4032
|
-
if (output[
|
|
4033
|
-
contents
|
|
4029
|
+
if (output[_Ti] != null) {
|
|
4030
|
+
contents[_Ti] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_Ti]));
|
|
4034
4031
|
}
|
|
4035
|
-
if (output[
|
|
4036
|
-
contents
|
|
4032
|
+
if (output[_AVp] != null) {
|
|
4033
|
+
contents[_AVp] = __strictParseFloat(output[_AVp]);
|
|
4037
4034
|
}
|
|
4038
4035
|
return contents;
|
|
4039
4036
|
};
|
|
@@ -4067,29 +4064,29 @@ const de_InsightRuleContributors = (output, context) => {
|
|
|
4067
4064
|
};
|
|
4068
4065
|
const de_InsightRuleMetricDatapoint = (output, context) => {
|
|
4069
4066
|
const contents = {};
|
|
4070
|
-
if (output[
|
|
4071
|
-
contents
|
|
4067
|
+
if (output[_Ti] != null) {
|
|
4068
|
+
contents[_Ti] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_Ti]));
|
|
4072
4069
|
}
|
|
4073
|
-
if (output[
|
|
4074
|
-
contents
|
|
4070
|
+
if (output[_UC] != null) {
|
|
4071
|
+
contents[_UC] = __strictParseFloat(output[_UC]);
|
|
4075
4072
|
}
|
|
4076
|
-
if (output[
|
|
4077
|
-
contents
|
|
4073
|
+
if (output[_MCV] != null) {
|
|
4074
|
+
contents[_MCV] = __strictParseFloat(output[_MCV]);
|
|
4078
4075
|
}
|
|
4079
|
-
if (output[
|
|
4080
|
-
contents
|
|
4076
|
+
if (output[_SCa] != null) {
|
|
4077
|
+
contents[_SCa] = __strictParseFloat(output[_SCa]);
|
|
4081
4078
|
}
|
|
4082
|
-
if (output[
|
|
4083
|
-
contents
|
|
4079
|
+
if (output[_Av] != null) {
|
|
4080
|
+
contents[_Av] = __strictParseFloat(output[_Av]);
|
|
4084
4081
|
}
|
|
4085
|
-
if (output[
|
|
4086
|
-
contents
|
|
4082
|
+
if (output[_Su] != null) {
|
|
4083
|
+
contents[_Su] = __strictParseFloat(output[_Su]);
|
|
4087
4084
|
}
|
|
4088
|
-
if (output[
|
|
4089
|
-
contents
|
|
4085
|
+
if (output[_Mi] != null) {
|
|
4086
|
+
contents[_Mi] = __strictParseFloat(output[_Mi]);
|
|
4090
4087
|
}
|
|
4091
|
-
if (output[
|
|
4092
|
-
contents
|
|
4088
|
+
if (output[_Ma] != null) {
|
|
4089
|
+
contents[_Ma] = __strictParseFloat(output[_Ma]);
|
|
4093
4090
|
}
|
|
4094
4091
|
return contents;
|
|
4095
4092
|
};
|
|
@@ -4109,131 +4106,131 @@ const de_InsightRules = (output, context) => {
|
|
|
4109
4106
|
};
|
|
4110
4107
|
const de_InternalServiceFault = (output, context) => {
|
|
4111
4108
|
const contents = {};
|
|
4112
|
-
if (output[
|
|
4113
|
-
contents
|
|
4109
|
+
if (output[_Mes] != null) {
|
|
4110
|
+
contents[_Mes] = __expectString(output[_Mes]);
|
|
4114
4111
|
}
|
|
4115
4112
|
return contents;
|
|
4116
4113
|
};
|
|
4117
4114
|
const de_InvalidFormatFault = (output, context) => {
|
|
4118
4115
|
const contents = {};
|
|
4119
|
-
if (output[
|
|
4120
|
-
contents
|
|
4116
|
+
if (output[_me] != null) {
|
|
4117
|
+
contents[_me] = __expectString(output[_me]);
|
|
4121
4118
|
}
|
|
4122
4119
|
return contents;
|
|
4123
4120
|
};
|
|
4124
4121
|
const de_InvalidNextToken = (output, context) => {
|
|
4125
4122
|
const contents = {};
|
|
4126
|
-
if (output[
|
|
4127
|
-
contents
|
|
4123
|
+
if (output[_me] != null) {
|
|
4124
|
+
contents[_me] = __expectString(output[_me]);
|
|
4128
4125
|
}
|
|
4129
4126
|
return contents;
|
|
4130
4127
|
};
|
|
4131
4128
|
const de_InvalidParameterCombinationException = (output, context) => {
|
|
4132
4129
|
const contents = {};
|
|
4133
|
-
if (output[
|
|
4134
|
-
contents
|
|
4130
|
+
if (output[_me] != null) {
|
|
4131
|
+
contents[_me] = __expectString(output[_me]);
|
|
4135
4132
|
}
|
|
4136
4133
|
return contents;
|
|
4137
4134
|
};
|
|
4138
4135
|
const de_InvalidParameterValueException = (output, context) => {
|
|
4139
4136
|
const contents = {};
|
|
4140
|
-
if (output[
|
|
4141
|
-
contents
|
|
4137
|
+
if (output[_me] != null) {
|
|
4138
|
+
contents[_me] = __expectString(output[_me]);
|
|
4142
4139
|
}
|
|
4143
4140
|
return contents;
|
|
4144
4141
|
};
|
|
4145
4142
|
const de_LimitExceededException = (output, context) => {
|
|
4146
4143
|
const contents = {};
|
|
4147
|
-
if (output[
|
|
4148
|
-
contents
|
|
4144
|
+
if (output[_Mes] != null) {
|
|
4145
|
+
contents[_Mes] = __expectString(output[_Mes]);
|
|
4149
4146
|
}
|
|
4150
4147
|
return contents;
|
|
4151
4148
|
};
|
|
4152
4149
|
const de_LimitExceededFault = (output, context) => {
|
|
4153
4150
|
const contents = {};
|
|
4154
|
-
if (output[
|
|
4155
|
-
contents
|
|
4151
|
+
if (output[_me] != null) {
|
|
4152
|
+
contents[_me] = __expectString(output[_me]);
|
|
4156
4153
|
}
|
|
4157
4154
|
return contents;
|
|
4158
4155
|
};
|
|
4159
4156
|
const de_ListDashboardsOutput = (output, context) => {
|
|
4160
4157
|
const contents = {};
|
|
4161
4158
|
if (output.DashboardEntries === "") {
|
|
4162
|
-
contents
|
|
4159
|
+
contents[_DE] = [];
|
|
4163
4160
|
}
|
|
4164
|
-
else if (output[
|
|
4165
|
-
contents
|
|
4161
|
+
else if (output[_DE] != null && output[_DE][_m] != null) {
|
|
4162
|
+
contents[_DE] = de_DashboardEntries(__getArrayIfSingleItem(output[_DE][_m]), context);
|
|
4166
4163
|
}
|
|
4167
|
-
if (output[
|
|
4168
|
-
contents
|
|
4164
|
+
if (output[_NT] != null) {
|
|
4165
|
+
contents[_NT] = __expectString(output[_NT]);
|
|
4169
4166
|
}
|
|
4170
4167
|
return contents;
|
|
4171
4168
|
};
|
|
4172
4169
|
const de_ListManagedInsightRulesOutput = (output, context) => {
|
|
4173
4170
|
const contents = {};
|
|
4174
4171
|
if (output.ManagedRules === "") {
|
|
4175
|
-
contents
|
|
4172
|
+
contents[_MRan] = [];
|
|
4176
4173
|
}
|
|
4177
|
-
else if (output[
|
|
4178
|
-
contents
|
|
4174
|
+
else if (output[_MRan] != null && output[_MRan][_m] != null) {
|
|
4175
|
+
contents[_MRan] = de_ManagedRuleDescriptions(__getArrayIfSingleItem(output[_MRan][_m]), context);
|
|
4179
4176
|
}
|
|
4180
|
-
if (output[
|
|
4181
|
-
contents
|
|
4177
|
+
if (output[_NT] != null) {
|
|
4178
|
+
contents[_NT] = __expectString(output[_NT]);
|
|
4182
4179
|
}
|
|
4183
4180
|
return contents;
|
|
4184
4181
|
};
|
|
4185
4182
|
const de_ListMetricsOutput = (output, context) => {
|
|
4186
4183
|
const contents = {};
|
|
4187
4184
|
if (output.Metrics === "") {
|
|
4188
|
-
contents
|
|
4185
|
+
contents[_M] = [];
|
|
4189
4186
|
}
|
|
4190
|
-
else if (output[
|
|
4191
|
-
contents
|
|
4187
|
+
else if (output[_M] != null && output[_M][_m] != null) {
|
|
4188
|
+
contents[_M] = de_Metrics(__getArrayIfSingleItem(output[_M][_m]), context);
|
|
4192
4189
|
}
|
|
4193
|
-
if (output[
|
|
4194
|
-
contents
|
|
4190
|
+
if (output[_NT] != null) {
|
|
4191
|
+
contents[_NT] = __expectString(output[_NT]);
|
|
4195
4192
|
}
|
|
4196
4193
|
if (output.OwningAccounts === "") {
|
|
4197
|
-
contents
|
|
4194
|
+
contents[_OAw] = [];
|
|
4198
4195
|
}
|
|
4199
|
-
else if (output[
|
|
4200
|
-
contents
|
|
4196
|
+
else if (output[_OAw] != null && output[_OAw][_m] != null) {
|
|
4197
|
+
contents[_OAw] = de_OwningAccounts(__getArrayIfSingleItem(output[_OAw][_m]), context);
|
|
4201
4198
|
}
|
|
4202
4199
|
return contents;
|
|
4203
4200
|
};
|
|
4204
4201
|
const de_ListMetricStreamsOutput = (output, context) => {
|
|
4205
4202
|
const contents = {};
|
|
4206
|
-
if (output[
|
|
4207
|
-
contents
|
|
4203
|
+
if (output[_NT] != null) {
|
|
4204
|
+
contents[_NT] = __expectString(output[_NT]);
|
|
4208
4205
|
}
|
|
4209
4206
|
if (output.Entries === "") {
|
|
4210
|
-
contents
|
|
4207
|
+
contents[_En] = [];
|
|
4211
4208
|
}
|
|
4212
|
-
else if (output[
|
|
4213
|
-
contents
|
|
4209
|
+
else if (output[_En] != null && output[_En][_m] != null) {
|
|
4210
|
+
contents[_En] = de_MetricStreamEntries(__getArrayIfSingleItem(output[_En][_m]), context);
|
|
4214
4211
|
}
|
|
4215
4212
|
return contents;
|
|
4216
4213
|
};
|
|
4217
4214
|
const de_ListTagsForResourceOutput = (output, context) => {
|
|
4218
4215
|
const contents = {};
|
|
4219
4216
|
if (output.Tags === "") {
|
|
4220
|
-
contents
|
|
4217
|
+
contents[_Ta] = [];
|
|
4221
4218
|
}
|
|
4222
|
-
else if (output[
|
|
4223
|
-
contents
|
|
4219
|
+
else if (output[_Ta] != null && output[_Ta][_m] != null) {
|
|
4220
|
+
contents[_Ta] = de_TagList(__getArrayIfSingleItem(output[_Ta][_m]), context);
|
|
4224
4221
|
}
|
|
4225
4222
|
return contents;
|
|
4226
4223
|
};
|
|
4227
4224
|
const de_ManagedRuleDescription = (output, context) => {
|
|
4228
4225
|
const contents = {};
|
|
4229
|
-
if (output[
|
|
4230
|
-
contents
|
|
4226
|
+
if (output[_TN] != null) {
|
|
4227
|
+
contents[_TN] = __expectString(output[_TN]);
|
|
4231
4228
|
}
|
|
4232
|
-
if (output[
|
|
4233
|
-
contents
|
|
4229
|
+
if (output[_RARN] != null) {
|
|
4230
|
+
contents[_RARN] = __expectString(output[_RARN]);
|
|
4234
4231
|
}
|
|
4235
|
-
if (output[
|
|
4236
|
-
contents
|
|
4232
|
+
if (output[_RS] != null) {
|
|
4233
|
+
contents[_RS] = de_ManagedRuleState(output[_RS], context);
|
|
4237
4234
|
}
|
|
4238
4235
|
return contents;
|
|
4239
4236
|
};
|
|
@@ -4246,144 +4243,143 @@ const de_ManagedRuleDescriptions = (output, context) => {
|
|
|
4246
4243
|
};
|
|
4247
4244
|
const de_ManagedRuleState = (output, context) => {
|
|
4248
4245
|
const contents = {};
|
|
4249
|
-
if (output[
|
|
4250
|
-
contents
|
|
4246
|
+
if (output[_RNu] != null) {
|
|
4247
|
+
contents[_RNu] = __expectString(output[_RNu]);
|
|
4251
4248
|
}
|
|
4252
|
-
if (output[
|
|
4253
|
-
contents
|
|
4249
|
+
if (output[_Stat] != null) {
|
|
4250
|
+
contents[_Stat] = __expectString(output[_Stat]);
|
|
4254
4251
|
}
|
|
4255
4252
|
return contents;
|
|
4256
4253
|
};
|
|
4257
4254
|
const de_MessageData = (output, context) => {
|
|
4258
4255
|
const contents = {};
|
|
4259
|
-
if (output[
|
|
4260
|
-
contents
|
|
4256
|
+
if (output[_Cod] != null) {
|
|
4257
|
+
contents[_Cod] = __expectString(output[_Cod]);
|
|
4261
4258
|
}
|
|
4262
|
-
if (output[
|
|
4263
|
-
contents
|
|
4259
|
+
if (output[_Va] != null) {
|
|
4260
|
+
contents[_Va] = __expectString(output[_Va]);
|
|
4264
4261
|
}
|
|
4265
4262
|
return contents;
|
|
4266
4263
|
};
|
|
4267
4264
|
const de_Metric = (output, context) => {
|
|
4268
4265
|
const contents = {};
|
|
4269
|
-
if (output[
|
|
4270
|
-
contents
|
|
4266
|
+
if (output[_N] != null) {
|
|
4267
|
+
contents[_N] = __expectString(output[_N]);
|
|
4271
4268
|
}
|
|
4272
|
-
if (output[
|
|
4273
|
-
contents
|
|
4269
|
+
if (output[_MN] != null) {
|
|
4270
|
+
contents[_MN] = __expectString(output[_MN]);
|
|
4274
4271
|
}
|
|
4275
4272
|
if (output.Dimensions === "") {
|
|
4276
|
-
contents
|
|
4273
|
+
contents[_D] = [];
|
|
4277
4274
|
}
|
|
4278
|
-
else if (output[
|
|
4279
|
-
contents
|
|
4275
|
+
else if (output[_D] != null && output[_D][_m] != null) {
|
|
4276
|
+
contents[_D] = de_Dimensions(__getArrayIfSingleItem(output[_D][_m]), context);
|
|
4280
4277
|
}
|
|
4281
4278
|
return contents;
|
|
4282
4279
|
};
|
|
4283
4280
|
const de_MetricAlarm = (output, context) => {
|
|
4284
4281
|
const contents = {};
|
|
4285
|
-
if (output[
|
|
4286
|
-
contents
|
|
4282
|
+
if (output[_ANl] != null) {
|
|
4283
|
+
contents[_ANl] = __expectString(output[_ANl]);
|
|
4287
4284
|
}
|
|
4288
|
-
if (output[
|
|
4289
|
-
contents
|
|
4285
|
+
if (output[_AAl] != null) {
|
|
4286
|
+
contents[_AAl] = __expectString(output[_AAl]);
|
|
4290
4287
|
}
|
|
4291
|
-
if (output[
|
|
4292
|
-
contents
|
|
4288
|
+
if (output[_AD] != null) {
|
|
4289
|
+
contents[_AD] = __expectString(output[_AD]);
|
|
4293
4290
|
}
|
|
4294
|
-
if (output[
|
|
4295
|
-
contents
|
|
4291
|
+
if (output[_ACUT] != null) {
|
|
4292
|
+
contents[_ACUT] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_ACUT]));
|
|
4296
4293
|
}
|
|
4297
|
-
if (output[
|
|
4298
|
-
contents
|
|
4294
|
+
if (output[_AE] != null) {
|
|
4295
|
+
contents[_AE] = __parseBoolean(output[_AE]);
|
|
4299
4296
|
}
|
|
4300
4297
|
if (output.OKActions === "") {
|
|
4301
|
-
contents
|
|
4298
|
+
contents[_OKA] = [];
|
|
4302
4299
|
}
|
|
4303
|
-
else if (output[
|
|
4304
|
-
contents
|
|
4300
|
+
else if (output[_OKA] != null && output[_OKA][_m] != null) {
|
|
4301
|
+
contents[_OKA] = de_ResourceList(__getArrayIfSingleItem(output[_OKA][_m]), context);
|
|
4305
4302
|
}
|
|
4306
4303
|
if (output.AlarmActions === "") {
|
|
4307
|
-
contents
|
|
4304
|
+
contents[_AA] = [];
|
|
4308
4305
|
}
|
|
4309
|
-
else if (output[
|
|
4310
|
-
contents
|
|
4306
|
+
else if (output[_AA] != null && output[_AA][_m] != null) {
|
|
4307
|
+
contents[_AA] = de_ResourceList(__getArrayIfSingleItem(output[_AA][_m]), context);
|
|
4311
4308
|
}
|
|
4312
4309
|
if (output.InsufficientDataActions === "") {
|
|
4313
|
-
contents
|
|
4310
|
+
contents[_IDA] = [];
|
|
4314
4311
|
}
|
|
4315
|
-
else if (output[
|
|
4316
|
-
output[
|
|
4317
|
-
contents.InsufficientDataActions = de_ResourceList(__getArrayIfSingleItem(output["InsufficientDataActions"]["member"]), context);
|
|
4312
|
+
else if (output[_IDA] != null && output[_IDA][_m] != null) {
|
|
4313
|
+
contents[_IDA] = de_ResourceList(__getArrayIfSingleItem(output[_IDA][_m]), context);
|
|
4318
4314
|
}
|
|
4319
|
-
if (output[
|
|
4320
|
-
contents
|
|
4315
|
+
if (output[_SV] != null) {
|
|
4316
|
+
contents[_SV] = __expectString(output[_SV]);
|
|
4321
4317
|
}
|
|
4322
|
-
if (output[
|
|
4323
|
-
contents
|
|
4318
|
+
if (output[_SRt] != null) {
|
|
4319
|
+
contents[_SRt] = __expectString(output[_SRt]);
|
|
4324
4320
|
}
|
|
4325
|
-
if (output[
|
|
4326
|
-
contents
|
|
4321
|
+
if (output[_SRD] != null) {
|
|
4322
|
+
contents[_SRD] = __expectString(output[_SRD]);
|
|
4327
4323
|
}
|
|
4328
|
-
if (output[
|
|
4329
|
-
contents
|
|
4324
|
+
if (output[_SUT] != null) {
|
|
4325
|
+
contents[_SUT] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_SUT]));
|
|
4330
4326
|
}
|
|
4331
|
-
if (output[
|
|
4332
|
-
contents
|
|
4327
|
+
if (output[_MN] != null) {
|
|
4328
|
+
contents[_MN] = __expectString(output[_MN]);
|
|
4333
4329
|
}
|
|
4334
|
-
if (output[
|
|
4335
|
-
contents
|
|
4330
|
+
if (output[_N] != null) {
|
|
4331
|
+
contents[_N] = __expectString(output[_N]);
|
|
4336
4332
|
}
|
|
4337
|
-
if (output[
|
|
4338
|
-
contents
|
|
4333
|
+
if (output[_St] != null) {
|
|
4334
|
+
contents[_St] = __expectString(output[_St]);
|
|
4339
4335
|
}
|
|
4340
|
-
if (output[
|
|
4341
|
-
contents
|
|
4336
|
+
if (output[_ES] != null) {
|
|
4337
|
+
contents[_ES] = __expectString(output[_ES]);
|
|
4342
4338
|
}
|
|
4343
4339
|
if (output.Dimensions === "") {
|
|
4344
|
-
contents
|
|
4340
|
+
contents[_D] = [];
|
|
4345
4341
|
}
|
|
4346
|
-
else if (output[
|
|
4347
|
-
contents
|
|
4342
|
+
else if (output[_D] != null && output[_D][_m] != null) {
|
|
4343
|
+
contents[_D] = de_Dimensions(__getArrayIfSingleItem(output[_D][_m]), context);
|
|
4348
4344
|
}
|
|
4349
|
-
if (output[
|
|
4350
|
-
contents
|
|
4345
|
+
if (output[_P] != null) {
|
|
4346
|
+
contents[_P] = __strictParseInt32(output[_P]);
|
|
4351
4347
|
}
|
|
4352
|
-
if (output[
|
|
4353
|
-
contents
|
|
4348
|
+
if (output[_U] != null) {
|
|
4349
|
+
contents[_U] = __expectString(output[_U]);
|
|
4354
4350
|
}
|
|
4355
|
-
if (output[
|
|
4356
|
-
contents
|
|
4351
|
+
if (output[_EP] != null) {
|
|
4352
|
+
contents[_EP] = __strictParseInt32(output[_EP]);
|
|
4357
4353
|
}
|
|
4358
|
-
if (output[
|
|
4359
|
-
contents
|
|
4354
|
+
if (output[_DTA] != null) {
|
|
4355
|
+
contents[_DTA] = __strictParseInt32(output[_DTA]);
|
|
4360
4356
|
}
|
|
4361
|
-
if (output[
|
|
4362
|
-
contents
|
|
4357
|
+
if (output[_Th] != null) {
|
|
4358
|
+
contents[_Th] = __strictParseFloat(output[_Th]);
|
|
4363
4359
|
}
|
|
4364
|
-
if (output[
|
|
4365
|
-
contents
|
|
4360
|
+
if (output[_CO] != null) {
|
|
4361
|
+
contents[_CO] = __expectString(output[_CO]);
|
|
4366
4362
|
}
|
|
4367
|
-
if (output[
|
|
4368
|
-
contents
|
|
4363
|
+
if (output[_TMD] != null) {
|
|
4364
|
+
contents[_TMD] = __expectString(output[_TMD]);
|
|
4369
4365
|
}
|
|
4370
|
-
if (output[
|
|
4371
|
-
contents
|
|
4366
|
+
if (output[_ELSCP] != null) {
|
|
4367
|
+
contents[_ELSCP] = __expectString(output[_ELSCP]);
|
|
4372
4368
|
}
|
|
4373
4369
|
if (output.Metrics === "") {
|
|
4374
|
-
contents
|
|
4370
|
+
contents[_M] = [];
|
|
4375
4371
|
}
|
|
4376
|
-
else if (output[
|
|
4377
|
-
contents
|
|
4372
|
+
else if (output[_M] != null && output[_M][_m] != null) {
|
|
4373
|
+
contents[_M] = de_MetricDataQueries(__getArrayIfSingleItem(output[_M][_m]), context);
|
|
4378
4374
|
}
|
|
4379
|
-
if (output[
|
|
4380
|
-
contents
|
|
4375
|
+
if (output[_TMI] != null) {
|
|
4376
|
+
contents[_TMI] = __expectString(output[_TMI]);
|
|
4381
4377
|
}
|
|
4382
|
-
if (output[
|
|
4383
|
-
contents
|
|
4378
|
+
if (output[_ESv] != null) {
|
|
4379
|
+
contents[_ESv] = __expectString(output[_ESv]);
|
|
4384
4380
|
}
|
|
4385
|
-
if (output[
|
|
4386
|
-
contents
|
|
4381
|
+
if (output[_STT] != null) {
|
|
4382
|
+
contents[_STT] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_STT]));
|
|
4387
4383
|
}
|
|
4388
4384
|
return contents;
|
|
4389
4385
|
};
|
|
@@ -4403,57 +4399,57 @@ const de_MetricDataQueries = (output, context) => {
|
|
|
4403
4399
|
};
|
|
4404
4400
|
const de_MetricDataQuery = (output, context) => {
|
|
4405
4401
|
const contents = {};
|
|
4406
|
-
if (output[
|
|
4407
|
-
contents
|
|
4402
|
+
if (output[_I] != null) {
|
|
4403
|
+
contents[_I] = __expectString(output[_I]);
|
|
4408
4404
|
}
|
|
4409
|
-
if (output[
|
|
4410
|
-
contents
|
|
4405
|
+
if (output[_MS] != null) {
|
|
4406
|
+
contents[_MS] = de_MetricStat(output[_MS], context);
|
|
4411
4407
|
}
|
|
4412
|
-
if (output[
|
|
4413
|
-
contents
|
|
4408
|
+
if (output[_E] != null) {
|
|
4409
|
+
contents[_E] = __expectString(output[_E]);
|
|
4414
4410
|
}
|
|
4415
|
-
if (output[
|
|
4416
|
-
contents
|
|
4411
|
+
if (output[_L] != null) {
|
|
4412
|
+
contents[_L] = __expectString(output[_L]);
|
|
4417
4413
|
}
|
|
4418
|
-
if (output[
|
|
4419
|
-
contents
|
|
4414
|
+
if (output[_RD] != null) {
|
|
4415
|
+
contents[_RD] = __parseBoolean(output[_RD]);
|
|
4420
4416
|
}
|
|
4421
|
-
if (output[
|
|
4422
|
-
contents
|
|
4417
|
+
if (output[_P] != null) {
|
|
4418
|
+
contents[_P] = __strictParseInt32(output[_P]);
|
|
4423
4419
|
}
|
|
4424
|
-
if (output[
|
|
4425
|
-
contents
|
|
4420
|
+
if (output[_AI] != null) {
|
|
4421
|
+
contents[_AI] = __expectString(output[_AI]);
|
|
4426
4422
|
}
|
|
4427
4423
|
return contents;
|
|
4428
4424
|
};
|
|
4429
4425
|
const de_MetricDataResult = (output, context) => {
|
|
4430
4426
|
const contents = {};
|
|
4431
|
-
if (output[
|
|
4432
|
-
contents
|
|
4427
|
+
if (output[_I] != null) {
|
|
4428
|
+
contents[_I] = __expectString(output[_I]);
|
|
4433
4429
|
}
|
|
4434
|
-
if (output[
|
|
4435
|
-
contents
|
|
4430
|
+
if (output[_L] != null) {
|
|
4431
|
+
contents[_L] = __expectString(output[_L]);
|
|
4436
4432
|
}
|
|
4437
4433
|
if (output.Timestamps === "") {
|
|
4438
|
-
contents
|
|
4434
|
+
contents[_Tim] = [];
|
|
4439
4435
|
}
|
|
4440
|
-
else if (output[
|
|
4441
|
-
contents
|
|
4436
|
+
else if (output[_Tim] != null && output[_Tim][_m] != null) {
|
|
4437
|
+
contents[_Tim] = de_Timestamps(__getArrayIfSingleItem(output[_Tim][_m]), context);
|
|
4442
4438
|
}
|
|
4443
4439
|
if (output.Values === "") {
|
|
4444
|
-
contents
|
|
4440
|
+
contents[_Val] = [];
|
|
4445
4441
|
}
|
|
4446
|
-
else if (output[
|
|
4447
|
-
contents
|
|
4442
|
+
else if (output[_Val] != null && output[_Val][_m] != null) {
|
|
4443
|
+
contents[_Val] = de_DatapointValues(__getArrayIfSingleItem(output[_Val][_m]), context);
|
|
4448
4444
|
}
|
|
4449
|
-
if (output[
|
|
4450
|
-
contents
|
|
4445
|
+
if (output[_SCt] != null) {
|
|
4446
|
+
contents[_SCt] = __expectString(output[_SCt]);
|
|
4451
4447
|
}
|
|
4452
4448
|
if (output.Messages === "") {
|
|
4453
|
-
contents
|
|
4449
|
+
contents[_Mess] = [];
|
|
4454
4450
|
}
|
|
4455
|
-
else if (output[
|
|
4456
|
-
contents
|
|
4451
|
+
else if (output[_Mess] != null && output[_Mess][_m] != null) {
|
|
4452
|
+
contents[_Mess] = de_MetricDataResultMessages(__getArrayIfSingleItem(output[_Mess][_m]), context);
|
|
4457
4453
|
}
|
|
4458
4454
|
return contents;
|
|
4459
4455
|
};
|
|
@@ -4474,10 +4470,10 @@ const de_MetricDataResults = (output, context) => {
|
|
|
4474
4470
|
const de_MetricMathAnomalyDetector = (output, context) => {
|
|
4475
4471
|
const contents = {};
|
|
4476
4472
|
if (output.MetricDataQueries === "") {
|
|
4477
|
-
contents
|
|
4473
|
+
contents[_MDQ] = [];
|
|
4478
4474
|
}
|
|
4479
|
-
else if (output[
|
|
4480
|
-
contents
|
|
4475
|
+
else if (output[_MDQ] != null && output[_MDQ][_m] != null) {
|
|
4476
|
+
contents[_MDQ] = de_MetricDataQueries(__getArrayIfSingleItem(output[_MDQ][_m]), context);
|
|
4481
4477
|
}
|
|
4482
4478
|
return contents;
|
|
4483
4479
|
};
|
|
@@ -4490,17 +4486,17 @@ const de_Metrics = (output, context) => {
|
|
|
4490
4486
|
};
|
|
4491
4487
|
const de_MetricStat = (output, context) => {
|
|
4492
4488
|
const contents = {};
|
|
4493
|
-
if (output[
|
|
4494
|
-
contents
|
|
4489
|
+
if (output[_Me] != null) {
|
|
4490
|
+
contents[_Me] = de_Metric(output[_Me], context);
|
|
4495
4491
|
}
|
|
4496
|
-
if (output[
|
|
4497
|
-
contents
|
|
4492
|
+
if (output[_P] != null) {
|
|
4493
|
+
contents[_P] = __strictParseInt32(output[_P]);
|
|
4498
4494
|
}
|
|
4499
|
-
if (output[
|
|
4500
|
-
contents
|
|
4495
|
+
if (output[_S] != null) {
|
|
4496
|
+
contents[_S] = __expectString(output[_S]);
|
|
4501
4497
|
}
|
|
4502
|
-
if (output[
|
|
4503
|
-
contents
|
|
4498
|
+
if (output[_U] != null) {
|
|
4499
|
+
contents[_U] = __expectString(output[_U]);
|
|
4504
4500
|
}
|
|
4505
4501
|
return contents;
|
|
4506
4502
|
};
|
|
@@ -4513,39 +4509,39 @@ const de_MetricStreamEntries = (output, context) => {
|
|
|
4513
4509
|
};
|
|
4514
4510
|
const de_MetricStreamEntry = (output, context) => {
|
|
4515
4511
|
const contents = {};
|
|
4516
|
-
if (output[
|
|
4517
|
-
contents
|
|
4512
|
+
if (output[_Ar] != null) {
|
|
4513
|
+
contents[_Ar] = __expectString(output[_Ar]);
|
|
4518
4514
|
}
|
|
4519
|
-
if (output[
|
|
4520
|
-
contents
|
|
4515
|
+
if (output[_CD] != null) {
|
|
4516
|
+
contents[_CD] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_CD]));
|
|
4521
4517
|
}
|
|
4522
|
-
if (output[
|
|
4523
|
-
contents
|
|
4518
|
+
if (output[_LUD] != null) {
|
|
4519
|
+
contents[_LUD] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_LUD]));
|
|
4524
4520
|
}
|
|
4525
|
-
if (output[
|
|
4526
|
-
contents
|
|
4521
|
+
if (output[_Na] != null) {
|
|
4522
|
+
contents[_Na] = __expectString(output[_Na]);
|
|
4527
4523
|
}
|
|
4528
|
-
if (output[
|
|
4529
|
-
contents
|
|
4524
|
+
if (output[_FA] != null) {
|
|
4525
|
+
contents[_FA] = __expectString(output[_FA]);
|
|
4530
4526
|
}
|
|
4531
|
-
if (output[
|
|
4532
|
-
contents
|
|
4527
|
+
if (output[_Stat] != null) {
|
|
4528
|
+
contents[_Stat] = __expectString(output[_Stat]);
|
|
4533
4529
|
}
|
|
4534
|
-
if (output[
|
|
4535
|
-
contents
|
|
4530
|
+
if (output[_OF] != null) {
|
|
4531
|
+
contents[_OF] = __expectString(output[_OF]);
|
|
4536
4532
|
}
|
|
4537
4533
|
return contents;
|
|
4538
4534
|
};
|
|
4539
4535
|
const de_MetricStreamFilter = (output, context) => {
|
|
4540
4536
|
const contents = {};
|
|
4541
|
-
if (output[
|
|
4542
|
-
contents
|
|
4537
|
+
if (output[_N] != null) {
|
|
4538
|
+
contents[_N] = __expectString(output[_N]);
|
|
4543
4539
|
}
|
|
4544
4540
|
if (output.MetricNames === "") {
|
|
4545
|
-
contents
|
|
4541
|
+
contents[_MNe] = [];
|
|
4546
4542
|
}
|
|
4547
|
-
else if (output[
|
|
4548
|
-
contents
|
|
4543
|
+
else if (output[_MNe] != null && output[_MNe][_m] != null) {
|
|
4544
|
+
contents[_MNe] = de_MetricStreamFilterMetricNames(__getArrayIfSingleItem(output[_MNe][_m]), context);
|
|
4549
4545
|
}
|
|
4550
4546
|
return contents;
|
|
4551
4547
|
};
|
|
@@ -4573,16 +4569,16 @@ const de_MetricStreamStatisticsAdditionalStatistics = (output, context) => {
|
|
|
4573
4569
|
const de_MetricStreamStatisticsConfiguration = (output, context) => {
|
|
4574
4570
|
const contents = {};
|
|
4575
4571
|
if (output.IncludeMetrics === "") {
|
|
4576
|
-
contents
|
|
4572
|
+
contents[_IM] = [];
|
|
4577
4573
|
}
|
|
4578
|
-
else if (output[
|
|
4579
|
-
contents
|
|
4574
|
+
else if (output[_IM] != null && output[_IM][_m] != null) {
|
|
4575
|
+
contents[_IM] = de_MetricStreamStatisticsIncludeMetrics(__getArrayIfSingleItem(output[_IM][_m]), context);
|
|
4580
4576
|
}
|
|
4581
4577
|
if (output.AdditionalStatistics === "") {
|
|
4582
|
-
contents
|
|
4578
|
+
contents[_AS] = [];
|
|
4583
4579
|
}
|
|
4584
|
-
else if (output[
|
|
4585
|
-
contents
|
|
4580
|
+
else if (output[_AS] != null && output[_AS][_m] != null) {
|
|
4581
|
+
contents[_AS] = de_MetricStreamStatisticsAdditionalStatistics(__getArrayIfSingleItem(output[_AS][_m]), context);
|
|
4586
4582
|
}
|
|
4587
4583
|
return contents;
|
|
4588
4584
|
};
|
|
@@ -4602,18 +4598,18 @@ const de_MetricStreamStatisticsIncludeMetrics = (output, context) => {
|
|
|
4602
4598
|
};
|
|
4603
4599
|
const de_MetricStreamStatisticsMetric = (output, context) => {
|
|
4604
4600
|
const contents = {};
|
|
4605
|
-
if (output[
|
|
4606
|
-
contents
|
|
4601
|
+
if (output[_N] != null) {
|
|
4602
|
+
contents[_N] = __expectString(output[_N]);
|
|
4607
4603
|
}
|
|
4608
|
-
if (output[
|
|
4609
|
-
contents
|
|
4604
|
+
if (output[_MN] != null) {
|
|
4605
|
+
contents[_MN] = __expectString(output[_MN]);
|
|
4610
4606
|
}
|
|
4611
4607
|
return contents;
|
|
4612
4608
|
};
|
|
4613
4609
|
const de_MissingRequiredParameterException = (output, context) => {
|
|
4614
4610
|
const contents = {};
|
|
4615
|
-
if (output[
|
|
4616
|
-
contents
|
|
4611
|
+
if (output[_me] != null) {
|
|
4612
|
+
contents[_me] = __expectString(output[_me]);
|
|
4617
4613
|
}
|
|
4618
4614
|
return contents;
|
|
4619
4615
|
};
|
|
@@ -4626,17 +4622,17 @@ const de_OwningAccounts = (output, context) => {
|
|
|
4626
4622
|
};
|
|
4627
4623
|
const de_PartialFailure = (output, context) => {
|
|
4628
4624
|
const contents = {};
|
|
4629
|
-
if (output[
|
|
4630
|
-
contents
|
|
4625
|
+
if (output[_FR] != null) {
|
|
4626
|
+
contents[_FR] = __expectString(output[_FR]);
|
|
4631
4627
|
}
|
|
4632
|
-
if (output[
|
|
4633
|
-
contents
|
|
4628
|
+
if (output[_ETx] != null) {
|
|
4629
|
+
contents[_ETx] = __expectString(output[_ETx]);
|
|
4634
4630
|
}
|
|
4635
|
-
if (output[
|
|
4636
|
-
contents
|
|
4631
|
+
if (output[_FC] != null) {
|
|
4632
|
+
contents[_FC] = __expectString(output[_FC]);
|
|
4637
4633
|
}
|
|
4638
|
-
if (output[
|
|
4639
|
-
contents
|
|
4634
|
+
if (output[_FD] != null) {
|
|
4635
|
+
contents[_FD] = __expectString(output[_FD]);
|
|
4640
4636
|
}
|
|
4641
4637
|
return contents;
|
|
4642
4638
|
};
|
|
@@ -4647,11 +4643,10 @@ const de_PutAnomalyDetectorOutput = (output, context) => {
|
|
|
4647
4643
|
const de_PutDashboardOutput = (output, context) => {
|
|
4648
4644
|
const contents = {};
|
|
4649
4645
|
if (output.DashboardValidationMessages === "") {
|
|
4650
|
-
contents
|
|
4646
|
+
contents[_DVM] = [];
|
|
4651
4647
|
}
|
|
4652
|
-
else if (output[
|
|
4653
|
-
output[
|
|
4654
|
-
contents.DashboardValidationMessages = de_DashboardValidationMessages(__getArrayIfSingleItem(output["DashboardValidationMessages"]["member"]), context);
|
|
4648
|
+
else if (output[_DVM] != null && output[_DVM][_m] != null) {
|
|
4649
|
+
contents[_DVM] = de_DashboardValidationMessages(__getArrayIfSingleItem(output[_DVM][_m]), context);
|
|
4655
4650
|
}
|
|
4656
4651
|
return contents;
|
|
4657
4652
|
};
|
|
@@ -4662,27 +4657,27 @@ const de_PutInsightRuleOutput = (output, context) => {
|
|
|
4662
4657
|
const de_PutManagedInsightRulesOutput = (output, context) => {
|
|
4663
4658
|
const contents = {};
|
|
4664
4659
|
if (output.Failures === "") {
|
|
4665
|
-
contents
|
|
4660
|
+
contents[_F] = [];
|
|
4666
4661
|
}
|
|
4667
|
-
else if (output[
|
|
4668
|
-
contents
|
|
4662
|
+
else if (output[_F] != null && output[_F][_m] != null) {
|
|
4663
|
+
contents[_F] = de_BatchFailures(__getArrayIfSingleItem(output[_F][_m]), context);
|
|
4669
4664
|
}
|
|
4670
4665
|
return contents;
|
|
4671
4666
|
};
|
|
4672
4667
|
const de_PutMetricStreamOutput = (output, context) => {
|
|
4673
4668
|
const contents = {};
|
|
4674
|
-
if (output[
|
|
4675
|
-
contents
|
|
4669
|
+
if (output[_Ar] != null) {
|
|
4670
|
+
contents[_Ar] = __expectString(output[_Ar]);
|
|
4676
4671
|
}
|
|
4677
4672
|
return contents;
|
|
4678
4673
|
};
|
|
4679
4674
|
const de_Range = (output, context) => {
|
|
4680
4675
|
const contents = {};
|
|
4681
|
-
if (output[
|
|
4682
|
-
contents
|
|
4676
|
+
if (output[_ST] != null) {
|
|
4677
|
+
contents[_ST] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_ST]));
|
|
4683
4678
|
}
|
|
4684
|
-
if (output[
|
|
4685
|
-
contents
|
|
4679
|
+
if (output[_ET] != null) {
|
|
4680
|
+
contents[_ET] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_ET]));
|
|
4686
4681
|
}
|
|
4687
4682
|
return contents;
|
|
4688
4683
|
};
|
|
@@ -4695,40 +4690,40 @@ const de_ResourceList = (output, context) => {
|
|
|
4695
4690
|
};
|
|
4696
4691
|
const de_ResourceNotFound = (output, context) => {
|
|
4697
4692
|
const contents = {};
|
|
4698
|
-
if (output[
|
|
4699
|
-
contents
|
|
4693
|
+
if (output[_me] != null) {
|
|
4694
|
+
contents[_me] = __expectString(output[_me]);
|
|
4700
4695
|
}
|
|
4701
4696
|
return contents;
|
|
4702
4697
|
};
|
|
4703
4698
|
const de_ResourceNotFoundException = (output, context) => {
|
|
4704
4699
|
const contents = {};
|
|
4705
|
-
if (output[
|
|
4706
|
-
contents
|
|
4700
|
+
if (output[_RT] != null) {
|
|
4701
|
+
contents[_RT] = __expectString(output[_RT]);
|
|
4707
4702
|
}
|
|
4708
|
-
if (output[
|
|
4709
|
-
contents
|
|
4703
|
+
if (output[_RI] != null) {
|
|
4704
|
+
contents[_RI] = __expectString(output[_RI]);
|
|
4710
4705
|
}
|
|
4711
|
-
if (output[
|
|
4712
|
-
contents
|
|
4706
|
+
if (output[_Mes] != null) {
|
|
4707
|
+
contents[_Mes] = __expectString(output[_Mes]);
|
|
4713
4708
|
}
|
|
4714
4709
|
return contents;
|
|
4715
4710
|
};
|
|
4716
4711
|
const de_SingleMetricAnomalyDetector = (output, context) => {
|
|
4717
4712
|
const contents = {};
|
|
4718
|
-
if (output[
|
|
4719
|
-
contents
|
|
4713
|
+
if (output[_N] != null) {
|
|
4714
|
+
contents[_N] = __expectString(output[_N]);
|
|
4720
4715
|
}
|
|
4721
|
-
if (output[
|
|
4722
|
-
contents
|
|
4716
|
+
if (output[_MN] != null) {
|
|
4717
|
+
contents[_MN] = __expectString(output[_MN]);
|
|
4723
4718
|
}
|
|
4724
4719
|
if (output.Dimensions === "") {
|
|
4725
|
-
contents
|
|
4720
|
+
contents[_D] = [];
|
|
4726
4721
|
}
|
|
4727
|
-
else if (output[
|
|
4728
|
-
contents
|
|
4722
|
+
else if (output[_D] != null && output[_D][_m] != null) {
|
|
4723
|
+
contents[_D] = de_Dimensions(__getArrayIfSingleItem(output[_D][_m]), context);
|
|
4729
4724
|
}
|
|
4730
|
-
if (output[
|
|
4731
|
-
contents
|
|
4725
|
+
if (output[_S] != null) {
|
|
4726
|
+
contents[_S] = __expectString(output[_S]);
|
|
4732
4727
|
}
|
|
4733
4728
|
return contents;
|
|
4734
4729
|
};
|
|
@@ -4742,11 +4737,11 @@ const de_StopMetricStreamsOutput = (output, context) => {
|
|
|
4742
4737
|
};
|
|
4743
4738
|
const de_Tag = (output, context) => {
|
|
4744
4739
|
const contents = {};
|
|
4745
|
-
if (output[
|
|
4746
|
-
contents
|
|
4740
|
+
if (output[_K] != null) {
|
|
4741
|
+
contents[_K] = __expectString(output[_K]);
|
|
4747
4742
|
}
|
|
4748
|
-
if (output[
|
|
4749
|
-
contents
|
|
4743
|
+
if (output[_Va] != null) {
|
|
4744
|
+
contents[_Va] = __expectString(output[_Va]);
|
|
4750
4745
|
}
|
|
4751
4746
|
return contents;
|
|
4752
4747
|
};
|
|
@@ -4801,6 +4796,214 @@ const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, bod
|
|
|
4801
4796
|
const SHARED_HEADERS = {
|
|
4802
4797
|
"content-type": "application/x-www-form-urlencoded",
|
|
4803
4798
|
};
|
|
4799
|
+
const _ = "2010-08-01";
|
|
4800
|
+
const _A = "Action";
|
|
4801
|
+
const _AA = "AlarmActions";
|
|
4802
|
+
const _AAV = "ApproximateAggregateValue";
|
|
4803
|
+
const _AAl = "AlarmArn";
|
|
4804
|
+
const _ACUT = "AlarmConfigurationUpdatedTimestamp";
|
|
4805
|
+
const _AD = "AlarmDescription";
|
|
4806
|
+
const _ADT = "AnomalyDetectorTypes";
|
|
4807
|
+
const _ADn = "AnomalyDetectors";
|
|
4808
|
+
const _AE = "ActionsEnabled";
|
|
4809
|
+
const _AHI = "AlarmHistoryItems";
|
|
4810
|
+
const _AI = "AccountId";
|
|
4811
|
+
const _AN = "AlarmNames";
|
|
4812
|
+
const _ANP = "AlarmNamePrefix";
|
|
4813
|
+
const _ANl = "AlarmName";
|
|
4814
|
+
const _AP = "ActionPrefix";
|
|
4815
|
+
const _AR = "AlarmRule";
|
|
4816
|
+
const _AS = "AdditionalStatistics";
|
|
4817
|
+
const _ASB = "ActionsSuppressedBy";
|
|
4818
|
+
const _ASEP = "ActionsSuppressorExtensionPeriod";
|
|
4819
|
+
const _ASR = "ActionsSuppressedReason";
|
|
4820
|
+
const _ASWP = "ActionsSuppressorWaitPeriod";
|
|
4821
|
+
const _ASc = "ActionsSuppressor";
|
|
4822
|
+
const _ASg = "AggregationStatistic";
|
|
4823
|
+
const _AT = "AlarmTypes";
|
|
4824
|
+
const _ATl = "AlarmType";
|
|
4825
|
+
const _AUC = "ApproximateUniqueCount";
|
|
4826
|
+
const _AV = "AggregateValue";
|
|
4827
|
+
const _AVp = "ApproximateValue";
|
|
4828
|
+
const _Ar = "Arn";
|
|
4829
|
+
const _Av = "Average";
|
|
4830
|
+
const _C = "Counts";
|
|
4831
|
+
const _CA = "CompositeAlarms";
|
|
4832
|
+
const _CD = "CreationDate";
|
|
4833
|
+
const _CO = "ComparisonOperator";
|
|
4834
|
+
const _COAN = "ChildrenOfAlarmName";
|
|
4835
|
+
const _Co = "Configuration";
|
|
4836
|
+
const _Cod = "Code";
|
|
4837
|
+
const _Con = "Contributors";
|
|
4838
|
+
const _D = "Dimensions";
|
|
4839
|
+
const _DA = "DeleteAlarms";
|
|
4840
|
+
const _DAA = "DisableAlarmActions";
|
|
4841
|
+
const _DAD = "DeleteAnomalyDetector";
|
|
4842
|
+
const _DADe = "DescribeAnomalyDetectors";
|
|
4843
|
+
const _DAFM = "DescribeAlarmsForMetric";
|
|
4844
|
+
const _DAH = "DescribeAlarmHistory";
|
|
4845
|
+
const _DAa = "DashboardArn";
|
|
4846
|
+
const _DAe = "DescribeAlarms";
|
|
4847
|
+
const _DB = "DashboardBody";
|
|
4848
|
+
const _DD = "DeleteDashboards";
|
|
4849
|
+
const _DE = "DashboardEntries";
|
|
4850
|
+
const _DIR = "DeleteInsightRules";
|
|
4851
|
+
const _DIRe = "DescribeInsightRules";
|
|
4852
|
+
const _DIRi = "DisableInsightRules";
|
|
4853
|
+
const _DMS = "DeleteMetricStream";
|
|
4854
|
+
const _DN = "DashboardNames";
|
|
4855
|
+
const _DNP = "DashboardNamePrefix";
|
|
4856
|
+
const _DNa = "DashboardName";
|
|
4857
|
+
const _DP = "DataPath";
|
|
4858
|
+
const _DTA = "DatapointsToAlarm";
|
|
4859
|
+
const _DVM = "DashboardValidationMessages";
|
|
4860
|
+
const _Da = "Datapoints";
|
|
4861
|
+
const _De = "Definition";
|
|
4862
|
+
const _E = "Expression";
|
|
4863
|
+
const _EAA = "EnableAlarmActions";
|
|
4864
|
+
const _ED = "EndDate";
|
|
4865
|
+
const _EF = "ExcludeFilters";
|
|
4866
|
+
const _EIR = "EnableInsightRules";
|
|
4867
|
+
const _ELSCP = "EvaluateLowSampleCountPercentile";
|
|
4868
|
+
const _EP = "EvaluationPeriods";
|
|
4869
|
+
const _ES = "ExtendedStatistic";
|
|
4870
|
+
const _ESv = "EvaluationState";
|
|
4871
|
+
const _ESx = "ExtendedStatistics";
|
|
4872
|
+
const _ET = "EndTime";
|
|
4873
|
+
const _ETR = "ExcludedTimeRanges";
|
|
4874
|
+
const _ETx = "ExceptionType";
|
|
4875
|
+
const _En = "Entries";
|
|
4876
|
+
const _F = "Failures";
|
|
4877
|
+
const _FA = "FirehoseArn";
|
|
4878
|
+
const _FC = "FailureCode";
|
|
4879
|
+
const _FD = "FailureDescription";
|
|
4880
|
+
const _FR = "FailureResource";
|
|
4881
|
+
const _GD = "GetDashboard";
|
|
4882
|
+
const _GIRR = "GetInsightRuleReport";
|
|
4883
|
+
const _GMD = "GetMetricData";
|
|
4884
|
+
const _GMS = "GetMetricStatistics";
|
|
4885
|
+
const _GMSe = "GetMetricStream";
|
|
4886
|
+
const _GMWI = "GetMetricWidgetImage";
|
|
4887
|
+
const _HD = "HistoryData";
|
|
4888
|
+
const _HIT = "HistoryItemType";
|
|
4889
|
+
const _HS = "HistorySummary";
|
|
4890
|
+
const _I = "Id";
|
|
4891
|
+
const _IDA = "InsufficientDataActions";
|
|
4892
|
+
const _IF = "IncludeFilters";
|
|
4893
|
+
const _ILA = "IncludeLinkedAccounts";
|
|
4894
|
+
const _ILAM = "IncludeLinkedAccountsMetrics";
|
|
4895
|
+
const _IM = "IncludeMetrics";
|
|
4896
|
+
const _IR = "InsightRules";
|
|
4897
|
+
const _K = "Key";
|
|
4898
|
+
const _KL = "KeyLabels";
|
|
4899
|
+
const _Ke = "Keys";
|
|
4900
|
+
const _L = "Label";
|
|
4901
|
+
const _LD = "ListDashboards";
|
|
4902
|
+
const _LM = "ListMetrics";
|
|
4903
|
+
const _LMIR = "ListManagedInsightRules";
|
|
4904
|
+
const _LMS = "ListMetricStreams";
|
|
4905
|
+
const _LMa = "LastModified";
|
|
4906
|
+
const _LO = "LabelOptions";
|
|
4907
|
+
const _LTFR = "ListTagsForResource";
|
|
4908
|
+
const _LUD = "LastUpdateDate";
|
|
4909
|
+
const _M = "Metrics";
|
|
4910
|
+
const _MA = "MetricAlarms";
|
|
4911
|
+
const _MCC = "MaxContributorCount";
|
|
4912
|
+
const _MCV = "MaxContributorValue";
|
|
4913
|
+
const _MD = "MaxDatapoints";
|
|
4914
|
+
const _MDQ = "MetricDataQueries";
|
|
4915
|
+
const _MDR = "MetricDataResults";
|
|
4916
|
+
const _MDe = "MetricData";
|
|
4917
|
+
const _MDet = "MetricDatapoints";
|
|
4918
|
+
const _MMAD = "MetricMathAnomalyDetector";
|
|
4919
|
+
const _MN = "MetricName";
|
|
4920
|
+
const _MNe = "MetricNames";
|
|
4921
|
+
const _MR = "MaxRecords";
|
|
4922
|
+
const _MRa = "MaxResults";
|
|
4923
|
+
const _MRan = "ManagedRules";
|
|
4924
|
+
const _MRana = "ManagedRule";
|
|
4925
|
+
const _MS = "MetricStat";
|
|
4926
|
+
const _MT = "MetricTimezone";
|
|
4927
|
+
const _MW = "MetricWidget";
|
|
4928
|
+
const _MWI = "MetricWidgetImage";
|
|
4929
|
+
const _Ma = "Maximum";
|
|
4930
|
+
const _Me = "Metric";
|
|
4931
|
+
const _Mes = "Message";
|
|
4932
|
+
const _Mess = "Messages";
|
|
4933
|
+
const _Mi = "Minimum";
|
|
4934
|
+
const _N = "Namespace";
|
|
4935
|
+
const _NT = "NextToken";
|
|
4936
|
+
const _Na = "Name";
|
|
4937
|
+
const _Nam = "Names";
|
|
4938
|
+
const _OA = "OwningAccount";
|
|
4939
|
+
const _OAw = "OwningAccounts";
|
|
4940
|
+
const _OB = "OrderBy";
|
|
4941
|
+
const _OF = "OutputFormat";
|
|
4942
|
+
const _OKA = "OKActions";
|
|
4943
|
+
const _P = "Period";
|
|
4944
|
+
const _PAD = "PutAnomalyDetector";
|
|
4945
|
+
const _PCA = "PutCompositeAlarm";
|
|
4946
|
+
const _PD = "PutDashboard";
|
|
4947
|
+
const _PIR = "PutInsightRule";
|
|
4948
|
+
const _PMA = "PutMetricAlarm";
|
|
4949
|
+
const _PMD = "PutMetricData";
|
|
4950
|
+
const _PMIR = "PutManagedInsightRules";
|
|
4951
|
+
const _PMS = "PutMetricStream";
|
|
4952
|
+
const _POAN = "ParentsOfAlarmName";
|
|
4953
|
+
const _RA = "RecentlyActive";
|
|
4954
|
+
const _RARN = "ResourceARN";
|
|
4955
|
+
const _RAo = "RoleArn";
|
|
4956
|
+
const _RD = "ReturnData";
|
|
4957
|
+
const _RDu = "RuleDefinition";
|
|
4958
|
+
const _RI = "ResourceId";
|
|
4959
|
+
const _RN = "RuleNames";
|
|
4960
|
+
const _RNu = "RuleName";
|
|
4961
|
+
const _RS = "RuleState";
|
|
4962
|
+
const _RT = "ResourceType";
|
|
4963
|
+
const _S = "Stat";
|
|
4964
|
+
const _SAS = "SetAlarmState";
|
|
4965
|
+
const _SB = "ScanBy";
|
|
4966
|
+
const _SC = "StatisticsConfigurations";
|
|
4967
|
+
const _SCa = "SampleCount";
|
|
4968
|
+
const _SCt = "StatusCode";
|
|
4969
|
+
const _SD = "StartDate";
|
|
4970
|
+
const _SMAD = "SingleMetricAnomalyDetector";
|
|
4971
|
+
const _SMS = "StartMetricStreams";
|
|
4972
|
+
const _SMSt = "StopMetricStreams";
|
|
4973
|
+
const _SR = "StorageResolution";
|
|
4974
|
+
const _SRD = "StateReasonData";
|
|
4975
|
+
const _SRt = "StateReason";
|
|
4976
|
+
const _ST = "StartTime";
|
|
4977
|
+
const _STT = "StateTransitionedTimestamp";
|
|
4978
|
+
const _SUT = "StateUpdatedTimestamp";
|
|
4979
|
+
const _SV = "StateValue";
|
|
4980
|
+
const _SVt = "StatisticValues";
|
|
4981
|
+
const _Sc = "Schema";
|
|
4982
|
+
const _Si = "Size";
|
|
4983
|
+
const _St = "Statistic";
|
|
4984
|
+
const _Sta = "Statistics";
|
|
4985
|
+
const _Stat = "State";
|
|
4986
|
+
const _Su = "Sum";
|
|
4987
|
+
const _T = "Timezone";
|
|
4988
|
+
const _TK = "TagKeys";
|
|
4989
|
+
const _TMD = "TreatMissingData";
|
|
4990
|
+
const _TMI = "ThresholdMetricId";
|
|
4991
|
+
const _TN = "TemplateName";
|
|
4992
|
+
const _TR = "TagResource";
|
|
4993
|
+
const _Ta = "Tags";
|
|
4994
|
+
const _Th = "Threshold";
|
|
4995
|
+
const _Ti = "Timestamp";
|
|
4996
|
+
const _Tim = "Timestamps";
|
|
4997
|
+
const _U = "Unit";
|
|
4998
|
+
const _UC = "UniqueContributors";
|
|
4999
|
+
const _UR = "UntagResource";
|
|
5000
|
+
const _V = "Version";
|
|
5001
|
+
const _Va = "Value";
|
|
5002
|
+
const _Val = "Values";
|
|
5003
|
+
const _dVM = "dashboardValidationMessages";
|
|
5004
|
+
const _e = "entry";
|
|
5005
|
+
const _m = "member";
|
|
5006
|
+
const _me = "message";
|
|
4804
5007
|
const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
|
|
4805
5008
|
if (encoded.length) {
|
|
4806
5009
|
const parser = new XMLParser({
|