@aws-sdk/client-iot-events-data 3.899.0 → 3.906.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/dist-cjs/index.js +956 -1074
  2. package/package.json +37 -37
package/dist-cjs/index.js CHANGED
@@ -1,1116 +1,998 @@
1
- "use strict";
2
- var __defProp = Object.defineProperty;
3
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
- var __getOwnPropNames = Object.getOwnPropertyNames;
5
- var __hasOwnProp = Object.prototype.hasOwnProperty;
6
- var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
7
- var __export = (target, all) => {
8
- for (var name in all)
9
- __defProp(target, name, { get: all[name], enumerable: true });
1
+ 'use strict';
2
+
3
+ var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
4
+ var middlewareLogger = require('@aws-sdk/middleware-logger');
5
+ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
6
+ var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
7
+ var configResolver = require('@smithy/config-resolver');
8
+ var core = require('@smithy/core');
9
+ var middlewareContentLength = require('@smithy/middleware-content-length');
10
+ var middlewareEndpoint = require('@smithy/middleware-endpoint');
11
+ var middlewareRetry = require('@smithy/middleware-retry');
12
+ var smithyClient = require('@smithy/smithy-client');
13
+ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
14
+ var runtimeConfig = require('./runtimeConfig');
15
+ var regionConfigResolver = require('@aws-sdk/region-config-resolver');
16
+ var protocolHttp = require('@smithy/protocol-http');
17
+ var middlewareSerde = require('@smithy/middleware-serde');
18
+ var core$1 = require('@aws-sdk/core');
19
+
20
+ const resolveClientEndpointParameters = (options) => {
21
+ return Object.assign(options, {
22
+ useDualstackEndpoint: options.useDualstackEndpoint ?? false,
23
+ useFipsEndpoint: options.useFipsEndpoint ?? false,
24
+ defaultSigningName: "ioteventsdata",
25
+ });
10
26
  };
11
- var __copyProps = (to, from, except, desc) => {
12
- if (from && typeof from === "object" || typeof from === "function") {
13
- for (let key of __getOwnPropNames(from))
14
- if (!__hasOwnProp.call(to, key) && key !== except)
15
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
16
- }
17
- return to;
27
+ const commonParams = {
28
+ UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
29
+ Endpoint: { type: "builtInParams", name: "endpoint" },
30
+ Region: { type: "builtInParams", name: "region" },
31
+ UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
18
32
  };
19
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
20
-
21
- // src/index.ts
22
- var index_exports = {};
23
- __export(index_exports, {
24
- AlarmStateName: () => AlarmStateName,
25
- BatchAcknowledgeAlarmCommand: () => BatchAcknowledgeAlarmCommand,
26
- BatchDeleteDetectorCommand: () => BatchDeleteDetectorCommand,
27
- BatchDisableAlarmCommand: () => BatchDisableAlarmCommand,
28
- BatchEnableAlarmCommand: () => BatchEnableAlarmCommand,
29
- BatchPutMessageCommand: () => BatchPutMessageCommand,
30
- BatchResetAlarmCommand: () => BatchResetAlarmCommand,
31
- BatchSnoozeAlarmCommand: () => BatchSnoozeAlarmCommand,
32
- BatchUpdateDetectorCommand: () => BatchUpdateDetectorCommand,
33
- ComparisonOperator: () => ComparisonOperator,
34
- CustomerActionName: () => CustomerActionName,
35
- DescribeAlarmCommand: () => DescribeAlarmCommand,
36
- DescribeDetectorCommand: () => DescribeDetectorCommand,
37
- ErrorCode: () => ErrorCode,
38
- EventType: () => EventType,
39
- InternalFailureException: () => InternalFailureException,
40
- InvalidRequestException: () => InvalidRequestException,
41
- IoTEventsData: () => IoTEventsData,
42
- IoTEventsDataClient: () => IoTEventsDataClient,
43
- IoTEventsDataServiceException: () => IoTEventsDataServiceException,
44
- ListAlarmsCommand: () => ListAlarmsCommand,
45
- ListDetectorsCommand: () => ListDetectorsCommand,
46
- ResourceNotFoundException: () => ResourceNotFoundException,
47
- ServiceUnavailableException: () => ServiceUnavailableException,
48
- ThrottlingException: () => ThrottlingException,
49
- TriggerType: () => TriggerType,
50
- __Client: () => import_smithy_client.Client
51
- });
52
- module.exports = __toCommonJS(index_exports);
53
-
54
- // src/IoTEventsDataClient.ts
55
- var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
56
- var import_middleware_logger = require("@aws-sdk/middleware-logger");
57
- var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
58
- var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
59
- var import_config_resolver = require("@smithy/config-resolver");
60
- var import_core = require("@smithy/core");
61
- var import_middleware_content_length = require("@smithy/middleware-content-length");
62
- var import_middleware_endpoint = require("@smithy/middleware-endpoint");
63
- var import_middleware_retry = require("@smithy/middleware-retry");
64
-
65
- var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
66
33
 
67
- // src/endpoint/EndpointParameters.ts
68
- var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
69
- return Object.assign(options, {
70
- useDualstackEndpoint: options.useDualstackEndpoint ?? false,
71
- useFipsEndpoint: options.useFipsEndpoint ?? false,
72
- defaultSigningName: "ioteventsdata"
73
- });
74
- }, "resolveClientEndpointParameters");
75
- var commonParams = {
76
- UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
77
- Endpoint: { type: "builtInParams", name: "endpoint" },
78
- Region: { type: "builtInParams", name: "region" },
79
- UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
34
+ const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
35
+ const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
36
+ let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
37
+ let _credentials = runtimeConfig.credentials;
38
+ return {
39
+ setHttpAuthScheme(httpAuthScheme) {
40
+ const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
41
+ if (index === -1) {
42
+ _httpAuthSchemes.push(httpAuthScheme);
43
+ }
44
+ else {
45
+ _httpAuthSchemes.splice(index, 1, httpAuthScheme);
46
+ }
47
+ },
48
+ httpAuthSchemes() {
49
+ return _httpAuthSchemes;
50
+ },
51
+ setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
52
+ _httpAuthSchemeProvider = httpAuthSchemeProvider;
53
+ },
54
+ httpAuthSchemeProvider() {
55
+ return _httpAuthSchemeProvider;
56
+ },
57
+ setCredentials(credentials) {
58
+ _credentials = credentials;
59
+ },
60
+ credentials() {
61
+ return _credentials;
62
+ },
63
+ };
64
+ };
65
+ const resolveHttpAuthRuntimeConfig = (config) => {
66
+ return {
67
+ httpAuthSchemes: config.httpAuthSchemes(),
68
+ httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
69
+ credentials: config.credentials(),
70
+ };
80
71
  };
81
72
 
82
- // src/IoTEventsDataClient.ts
83
- var import_runtimeConfig = require("././runtimeConfig");
84
-
85
- // src/runtimeExtensions.ts
86
- var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
87
- var import_protocol_http = require("@smithy/protocol-http");
88
- var import_smithy_client = require("@smithy/smithy-client");
73
+ const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
74
+ const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
75
+ extensions.forEach((extension) => extension.configure(extensionConfiguration));
76
+ return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
77
+ };
89
78
 
90
- // src/auth/httpAuthExtensionConfiguration.ts
91
- var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
92
- const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
93
- let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
94
- let _credentials = runtimeConfig.credentials;
95
- return {
96
- setHttpAuthScheme(httpAuthScheme) {
97
- const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
98
- if (index === -1) {
99
- _httpAuthSchemes.push(httpAuthScheme);
100
- } else {
101
- _httpAuthSchemes.splice(index, 1, httpAuthScheme);
102
- }
103
- },
104
- httpAuthSchemes() {
105
- return _httpAuthSchemes;
106
- },
107
- setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
108
- _httpAuthSchemeProvider = httpAuthSchemeProvider;
109
- },
110
- httpAuthSchemeProvider() {
111
- return _httpAuthSchemeProvider;
112
- },
113
- setCredentials(credentials) {
114
- _credentials = credentials;
115
- },
116
- credentials() {
117
- return _credentials;
79
+ class IoTEventsDataClient extends smithyClient.Client {
80
+ config;
81
+ constructor(...[configuration]) {
82
+ const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
83
+ super(_config_0);
84
+ this.initConfig = _config_0;
85
+ const _config_1 = resolveClientEndpointParameters(_config_0);
86
+ const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
87
+ const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
88
+ const _config_4 = configResolver.resolveRegionConfig(_config_3);
89
+ const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
90
+ const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
91
+ const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
92
+ const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
93
+ this.config = _config_8;
94
+ this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
95
+ this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
96
+ this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
97
+ this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
98
+ this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
99
+ this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
100
+ this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
101
+ httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultIoTEventsDataHttpAuthSchemeParametersProvider,
102
+ identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
103
+ "aws.auth#sigv4": config.credentials,
104
+ }),
105
+ }));
106
+ this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
118
107
  }
119
- };
120
- }, "getHttpAuthExtensionConfiguration");
121
- var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
122
- return {
123
- httpAuthSchemes: config.httpAuthSchemes(),
124
- httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
125
- credentials: config.credentials()
126
- };
127
- }, "resolveHttpAuthRuntimeConfig");
128
-
129
- // src/runtimeExtensions.ts
130
- var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
131
- const extensionConfiguration = Object.assign(
132
- (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
133
- (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
134
- (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
135
- getHttpAuthExtensionConfiguration(runtimeConfig)
136
- );
137
- extensions.forEach((extension) => extension.configure(extensionConfiguration));
138
- return Object.assign(
139
- runtimeConfig,
140
- (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
141
- (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
142
- (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
143
- resolveHttpAuthRuntimeConfig(extensionConfiguration)
144
- );
145
- }, "resolveRuntimeExtensions");
108
+ destroy() {
109
+ super.destroy();
110
+ }
111
+ }
146
112
 
147
- // src/IoTEventsDataClient.ts
148
- var IoTEventsDataClient = class extends import_smithy_client.Client {
149
- static {
150
- __name(this, "IoTEventsDataClient");
151
- }
152
- /**
153
- * The resolved configuration of IoTEventsDataClient class. This is resolved and normalized from the {@link IoTEventsDataClientConfig | constructor configuration interface}.
154
- */
155
- config;
156
- constructor(...[configuration]) {
157
- const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
158
- super(_config_0);
159
- this.initConfig = _config_0;
160
- const _config_1 = resolveClientEndpointParameters(_config_0);
161
- const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
162
- const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
163
- const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
164
- const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
165
- const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
166
- const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
167
- const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
168
- this.config = _config_8;
169
- this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
170
- this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
171
- this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
172
- this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
173
- this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
174
- this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
175
- this.middlewareStack.use(
176
- (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
177
- httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultIoTEventsDataHttpAuthSchemeParametersProvider,
178
- identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
179
- "aws.auth#sigv4": config.credentials
180
- }), "identityProviderConfigProvider")
181
- })
182
- );
183
- this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
184
- }
185
- /**
186
- * Destroy underlying resources, like sockets. It's usually not necessary to do this.
187
- * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
188
- * Otherwise, sockets might stay open for quite a long time before the server terminates them.
189
- */
190
- destroy() {
191
- super.destroy();
192
- }
113
+ class IoTEventsDataServiceException extends smithyClient.ServiceException {
114
+ constructor(options) {
115
+ super(options);
116
+ Object.setPrototypeOf(this, IoTEventsDataServiceException.prototype);
117
+ }
118
+ }
119
+
120
+ const CustomerActionName = {
121
+ ACKNOWLEDGE: "ACKNOWLEDGE",
122
+ DISABLE: "DISABLE",
123
+ ENABLE: "ENABLE",
124
+ RESET: "RESET",
125
+ SNOOZE: "SNOOZE",
193
126
  };
194
-
195
- // src/IoTEventsData.ts
196
-
197
-
198
- // src/commands/BatchAcknowledgeAlarmCommand.ts
199
-
200
- var import_middleware_serde = require("@smithy/middleware-serde");
201
-
202
-
203
- // src/protocols/Aws_restJson1.ts
204
- var import_core2 = require("@aws-sdk/core");
205
-
206
-
207
-
208
- // src/models/IoTEventsDataServiceException.ts
209
-
210
- var IoTEventsDataServiceException = class _IoTEventsDataServiceException extends import_smithy_client.ServiceException {
211
- static {
212
- __name(this, "IoTEventsDataServiceException");
213
- }
214
- /**
215
- * @internal
216
- */
217
- constructor(options) {
218
- super(options);
219
- Object.setPrototypeOf(this, _IoTEventsDataServiceException.prototype);
220
- }
127
+ const ComparisonOperator = {
128
+ EQUAL: "EQUAL",
129
+ GREATER: "GREATER",
130
+ GREATER_OR_EQUAL: "GREATER_OR_EQUAL",
131
+ LESS: "LESS",
132
+ LESS_OR_EQUAL: "LESS_OR_EQUAL",
133
+ NOT_EQUAL: "NOT_EQUAL",
221
134
  };
222
-
223
- // src/models/models_0.ts
224
- var CustomerActionName = {
225
- ACKNOWLEDGE: "ACKNOWLEDGE",
226
- DISABLE: "DISABLE",
227
- ENABLE: "ENABLE",
228
- RESET: "RESET",
229
- SNOOZE: "SNOOZE"
135
+ const AlarmStateName = {
136
+ ACKNOWLEDGED: "ACKNOWLEDGED",
137
+ ACTIVE: "ACTIVE",
138
+ DISABLED: "DISABLED",
139
+ LATCHED: "LATCHED",
140
+ NORMAL: "NORMAL",
141
+ SNOOZE_DISABLED: "SNOOZE_DISABLED",
142
+ };
143
+ const EventType = {
144
+ STATE_CHANGE: "STATE_CHANGE",
145
+ };
146
+ const TriggerType = {
147
+ SNOOZE_TIMEOUT: "SNOOZE_TIMEOUT",
148
+ };
149
+ const ErrorCode = {
150
+ InternalFailureException: "InternalFailureException",
151
+ InvalidRequestException: "InvalidRequestException",
152
+ ResourceNotFoundException: "ResourceNotFoundException",
153
+ ServiceUnavailableException: "ServiceUnavailableException",
154
+ ThrottlingException: "ThrottlingException",
230
155
  };
231
- var ComparisonOperator = {
232
- EQUAL: "EQUAL",
233
- GREATER: "GREATER",
234
- GREATER_OR_EQUAL: "GREATER_OR_EQUAL",
235
- LESS: "LESS",
236
- LESS_OR_EQUAL: "LESS_OR_EQUAL",
237
- NOT_EQUAL: "NOT_EQUAL"
156
+ class InternalFailureException extends IoTEventsDataServiceException {
157
+ name = "InternalFailureException";
158
+ $fault = "server";
159
+ constructor(opts) {
160
+ super({
161
+ name: "InternalFailureException",
162
+ $fault: "server",
163
+ ...opts,
164
+ });
165
+ Object.setPrototypeOf(this, InternalFailureException.prototype);
166
+ }
167
+ }
168
+ class InvalidRequestException extends IoTEventsDataServiceException {
169
+ name = "InvalidRequestException";
170
+ $fault = "client";
171
+ constructor(opts) {
172
+ super({
173
+ name: "InvalidRequestException",
174
+ $fault: "client",
175
+ ...opts,
176
+ });
177
+ Object.setPrototypeOf(this, InvalidRequestException.prototype);
178
+ }
179
+ }
180
+ class ServiceUnavailableException extends IoTEventsDataServiceException {
181
+ name = "ServiceUnavailableException";
182
+ $fault = "server";
183
+ constructor(opts) {
184
+ super({
185
+ name: "ServiceUnavailableException",
186
+ $fault: "server",
187
+ ...opts,
188
+ });
189
+ Object.setPrototypeOf(this, ServiceUnavailableException.prototype);
190
+ }
191
+ }
192
+ class ThrottlingException extends IoTEventsDataServiceException {
193
+ name = "ThrottlingException";
194
+ $fault = "client";
195
+ constructor(opts) {
196
+ super({
197
+ name: "ThrottlingException",
198
+ $fault: "client",
199
+ ...opts,
200
+ });
201
+ Object.setPrototypeOf(this, ThrottlingException.prototype);
202
+ }
203
+ }
204
+ class ResourceNotFoundException extends IoTEventsDataServiceException {
205
+ name = "ResourceNotFoundException";
206
+ $fault = "client";
207
+ constructor(opts) {
208
+ super({
209
+ name: "ResourceNotFoundException",
210
+ $fault: "client",
211
+ ...opts,
212
+ });
213
+ Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
214
+ }
215
+ }
216
+
217
+ const se_BatchAcknowledgeAlarmCommand = async (input, context) => {
218
+ const b = core.requestBuilder(input, context);
219
+ const headers = {
220
+ "content-type": "application/json",
221
+ };
222
+ b.bp("/alarms/acknowledge");
223
+ let body;
224
+ body = JSON.stringify(smithyClient.take(input, {
225
+ acknowledgeActionRequests: (_) => smithyClient._json(_),
226
+ }));
227
+ b.m("POST").h(headers).b(body);
228
+ return b.build();
238
229
  };
239
- var AlarmStateName = {
240
- ACKNOWLEDGED: "ACKNOWLEDGED",
241
- ACTIVE: "ACTIVE",
242
- DISABLED: "DISABLED",
243
- LATCHED: "LATCHED",
244
- NORMAL: "NORMAL",
245
- SNOOZE_DISABLED: "SNOOZE_DISABLED"
230
+ const se_BatchDeleteDetectorCommand = async (input, context) => {
231
+ const b = core.requestBuilder(input, context);
232
+ const headers = {
233
+ "content-type": "application/json",
234
+ };
235
+ b.bp("/detectors/delete");
236
+ let body;
237
+ body = JSON.stringify(smithyClient.take(input, {
238
+ detectors: (_) => smithyClient._json(_),
239
+ }));
240
+ b.m("POST").h(headers).b(body);
241
+ return b.build();
246
242
  };
247
- var EventType = {
248
- STATE_CHANGE: "STATE_CHANGE"
243
+ const se_BatchDisableAlarmCommand = async (input, context) => {
244
+ const b = core.requestBuilder(input, context);
245
+ const headers = {
246
+ "content-type": "application/json",
247
+ };
248
+ b.bp("/alarms/disable");
249
+ let body;
250
+ body = JSON.stringify(smithyClient.take(input, {
251
+ disableActionRequests: (_) => smithyClient._json(_),
252
+ }));
253
+ b.m("POST").h(headers).b(body);
254
+ return b.build();
249
255
  };
250
- var TriggerType = {
251
- SNOOZE_TIMEOUT: "SNOOZE_TIMEOUT"
256
+ const se_BatchEnableAlarmCommand = async (input, context) => {
257
+ const b = core.requestBuilder(input, context);
258
+ const headers = {
259
+ "content-type": "application/json",
260
+ };
261
+ b.bp("/alarms/enable");
262
+ let body;
263
+ body = JSON.stringify(smithyClient.take(input, {
264
+ enableActionRequests: (_) => smithyClient._json(_),
265
+ }));
266
+ b.m("POST").h(headers).b(body);
267
+ return b.build();
252
268
  };
253
- var ErrorCode = {
254
- InternalFailureException: "InternalFailureException",
255
- InvalidRequestException: "InvalidRequestException",
256
- ResourceNotFoundException: "ResourceNotFoundException",
257
- ServiceUnavailableException: "ServiceUnavailableException",
258
- ThrottlingException: "ThrottlingException"
269
+ const se_BatchPutMessageCommand = async (input, context) => {
270
+ const b = core.requestBuilder(input, context);
271
+ const headers = {
272
+ "content-type": "application/json",
273
+ };
274
+ b.bp("/inputs/messages");
275
+ let body;
276
+ body = JSON.stringify(smithyClient.take(input, {
277
+ messages: (_) => se_Messages(_, context),
278
+ }));
279
+ b.m("POST").h(headers).b(body);
280
+ return b.build();
259
281
  };
260
- var InternalFailureException = class _InternalFailureException extends IoTEventsDataServiceException {
261
- static {
262
- __name(this, "InternalFailureException");
263
- }
264
- name = "InternalFailureException";
265
- $fault = "server";
266
- /**
267
- * @internal
268
- */
269
- constructor(opts) {
270
- super({
271
- name: "InternalFailureException",
272
- $fault: "server",
273
- ...opts
282
+ const se_BatchResetAlarmCommand = async (input, context) => {
283
+ const b = core.requestBuilder(input, context);
284
+ const headers = {
285
+ "content-type": "application/json",
286
+ };
287
+ b.bp("/alarms/reset");
288
+ let body;
289
+ body = JSON.stringify(smithyClient.take(input, {
290
+ resetActionRequests: (_) => smithyClient._json(_),
291
+ }));
292
+ b.m("POST").h(headers).b(body);
293
+ return b.build();
294
+ };
295
+ const se_BatchSnoozeAlarmCommand = async (input, context) => {
296
+ const b = core.requestBuilder(input, context);
297
+ const headers = {
298
+ "content-type": "application/json",
299
+ };
300
+ b.bp("/alarms/snooze");
301
+ let body;
302
+ body = JSON.stringify(smithyClient.take(input, {
303
+ snoozeActionRequests: (_) => smithyClient._json(_),
304
+ }));
305
+ b.m("POST").h(headers).b(body);
306
+ return b.build();
307
+ };
308
+ const se_BatchUpdateDetectorCommand = async (input, context) => {
309
+ const b = core.requestBuilder(input, context);
310
+ const headers = {
311
+ "content-type": "application/json",
312
+ };
313
+ b.bp("/detectors");
314
+ let body;
315
+ body = JSON.stringify(smithyClient.take(input, {
316
+ detectors: (_) => smithyClient._json(_),
317
+ }));
318
+ b.m("POST").h(headers).b(body);
319
+ return b.build();
320
+ };
321
+ const se_DescribeAlarmCommand = async (input, context) => {
322
+ const b = core.requestBuilder(input, context);
323
+ const headers = {};
324
+ b.bp("/alarms/{alarmModelName}/keyValues");
325
+ b.p("alarmModelName", () => input.alarmModelName, "{alarmModelName}", false);
326
+ const query = smithyClient.map({
327
+ [_kV]: [, input[_kV]],
274
328
  });
275
- Object.setPrototypeOf(this, _InternalFailureException.prototype);
276
- }
329
+ let body;
330
+ b.m("GET").h(headers).q(query).b(body);
331
+ return b.build();
277
332
  };
278
- var InvalidRequestException = class _InvalidRequestException extends IoTEventsDataServiceException {
279
- static {
280
- __name(this, "InvalidRequestException");
281
- }
282
- name = "InvalidRequestException";
283
- $fault = "client";
284
- /**
285
- * @internal
286
- */
287
- constructor(opts) {
288
- super({
289
- name: "InvalidRequestException",
290
- $fault: "client",
291
- ...opts
333
+ const se_DescribeDetectorCommand = async (input, context) => {
334
+ const b = core.requestBuilder(input, context);
335
+ const headers = {};
336
+ b.bp("/detectors/{detectorModelName}/keyValues");
337
+ b.p("detectorModelName", () => input.detectorModelName, "{detectorModelName}", false);
338
+ const query = smithyClient.map({
339
+ [_kV]: [, input[_kV]],
292
340
  });
293
- Object.setPrototypeOf(this, _InvalidRequestException.prototype);
294
- }
341
+ let body;
342
+ b.m("GET").h(headers).q(query).b(body);
343
+ return b.build();
295
344
  };
296
- var ServiceUnavailableException = class _ServiceUnavailableException extends IoTEventsDataServiceException {
297
- static {
298
- __name(this, "ServiceUnavailableException");
299
- }
300
- name = "ServiceUnavailableException";
301
- $fault = "server";
302
- /**
303
- * @internal
304
- */
305
- constructor(opts) {
306
- super({
307
- name: "ServiceUnavailableException",
308
- $fault: "server",
309
- ...opts
345
+ const se_ListAlarmsCommand = async (input, context) => {
346
+ const b = core.requestBuilder(input, context);
347
+ const headers = {};
348
+ b.bp("/alarms/{alarmModelName}");
349
+ b.p("alarmModelName", () => input.alarmModelName, "{alarmModelName}", false);
350
+ const query = smithyClient.map({
351
+ [_nT]: [, input[_nT]],
352
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
310
353
  });
311
- Object.setPrototypeOf(this, _ServiceUnavailableException.prototype);
312
- }
354
+ let body;
355
+ b.m("GET").h(headers).q(query).b(body);
356
+ return b.build();
313
357
  };
314
- var ThrottlingException = class _ThrottlingException extends IoTEventsDataServiceException {
315
- static {
316
- __name(this, "ThrottlingException");
317
- }
318
- name = "ThrottlingException";
319
- $fault = "client";
320
- /**
321
- * @internal
322
- */
323
- constructor(opts) {
324
- super({
325
- name: "ThrottlingException",
326
- $fault: "client",
327
- ...opts
358
+ const se_ListDetectorsCommand = async (input, context) => {
359
+ const b = core.requestBuilder(input, context);
360
+ const headers = {};
361
+ b.bp("/detectors/{detectorModelName}");
362
+ b.p("detectorModelName", () => input.detectorModelName, "{detectorModelName}", false);
363
+ const query = smithyClient.map({
364
+ [_sN]: [, input[_sN]],
365
+ [_nT]: [, input[_nT]],
366
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
328
367
  });
329
- Object.setPrototypeOf(this, _ThrottlingException.prototype);
330
- }
368
+ let body;
369
+ b.m("GET").h(headers).q(query).b(body);
370
+ return b.build();
331
371
  };
332
- var ResourceNotFoundException = class _ResourceNotFoundException extends IoTEventsDataServiceException {
333
- static {
334
- __name(this, "ResourceNotFoundException");
335
- }
336
- name = "ResourceNotFoundException";
337
- $fault = "client";
338
- /**
339
- * @internal
340
- */
341
- constructor(opts) {
342
- super({
343
- name: "ResourceNotFoundException",
344
- $fault: "client",
345
- ...opts
372
+ const de_BatchAcknowledgeAlarmCommand = async (output, context) => {
373
+ if (output.statusCode !== 202 && output.statusCode >= 300) {
374
+ return de_CommandError(output, context);
375
+ }
376
+ const contents = smithyClient.map({
377
+ $metadata: deserializeMetadata(output),
378
+ });
379
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
380
+ const doc = smithyClient.take(data, {
381
+ errorEntries: smithyClient._json,
346
382
  });
347
- Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
348
- }
383
+ Object.assign(contents, doc);
384
+ return contents;
349
385
  };
350
-
351
- // src/protocols/Aws_restJson1.ts
352
- var se_BatchAcknowledgeAlarmCommand = /* @__PURE__ */ __name(async (input, context) => {
353
- const b = (0, import_core.requestBuilder)(input, context);
354
- const headers = {
355
- "content-type": "application/json"
356
- };
357
- b.bp("/alarms/acknowledge");
358
- let body;
359
- body = JSON.stringify(
360
- (0, import_smithy_client.take)(input, {
361
- acknowledgeActionRequests: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "acknowledgeActionRequests")
362
- })
363
- );
364
- b.m("POST").h(headers).b(body);
365
- return b.build();
366
- }, "se_BatchAcknowledgeAlarmCommand");
367
- var se_BatchDeleteDetectorCommand = /* @__PURE__ */ __name(async (input, context) => {
368
- const b = (0, import_core.requestBuilder)(input, context);
369
- const headers = {
370
- "content-type": "application/json"
371
- };
372
- b.bp("/detectors/delete");
373
- let body;
374
- body = JSON.stringify(
375
- (0, import_smithy_client.take)(input, {
376
- detectors: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "detectors")
377
- })
378
- );
379
- b.m("POST").h(headers).b(body);
380
- return b.build();
381
- }, "se_BatchDeleteDetectorCommand");
382
- var se_BatchDisableAlarmCommand = /* @__PURE__ */ __name(async (input, context) => {
383
- const b = (0, import_core.requestBuilder)(input, context);
384
- const headers = {
385
- "content-type": "application/json"
386
- };
387
- b.bp("/alarms/disable");
388
- let body;
389
- body = JSON.stringify(
390
- (0, import_smithy_client.take)(input, {
391
- disableActionRequests: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "disableActionRequests")
392
- })
393
- );
394
- b.m("POST").h(headers).b(body);
395
- return b.build();
396
- }, "se_BatchDisableAlarmCommand");
397
- var se_BatchEnableAlarmCommand = /* @__PURE__ */ __name(async (input, context) => {
398
- const b = (0, import_core.requestBuilder)(input, context);
399
- const headers = {
400
- "content-type": "application/json"
401
- };
402
- b.bp("/alarms/enable");
403
- let body;
404
- body = JSON.stringify(
405
- (0, import_smithy_client.take)(input, {
406
- enableActionRequests: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "enableActionRequests")
407
- })
408
- );
409
- b.m("POST").h(headers).b(body);
410
- return b.build();
411
- }, "se_BatchEnableAlarmCommand");
412
- var se_BatchPutMessageCommand = /* @__PURE__ */ __name(async (input, context) => {
413
- const b = (0, import_core.requestBuilder)(input, context);
414
- const headers = {
415
- "content-type": "application/json"
416
- };
417
- b.bp("/inputs/messages");
418
- let body;
419
- body = JSON.stringify(
420
- (0, import_smithy_client.take)(input, {
421
- messages: /* @__PURE__ */ __name((_) => se_Messages(_, context), "messages")
422
- })
423
- );
424
- b.m("POST").h(headers).b(body);
425
- return b.build();
426
- }, "se_BatchPutMessageCommand");
427
- var se_BatchResetAlarmCommand = /* @__PURE__ */ __name(async (input, context) => {
428
- const b = (0, import_core.requestBuilder)(input, context);
429
- const headers = {
430
- "content-type": "application/json"
431
- };
432
- b.bp("/alarms/reset");
433
- let body;
434
- body = JSON.stringify(
435
- (0, import_smithy_client.take)(input, {
436
- resetActionRequests: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "resetActionRequests")
437
- })
438
- );
439
- b.m("POST").h(headers).b(body);
440
- return b.build();
441
- }, "se_BatchResetAlarmCommand");
442
- var se_BatchSnoozeAlarmCommand = /* @__PURE__ */ __name(async (input, context) => {
443
- const b = (0, import_core.requestBuilder)(input, context);
444
- const headers = {
445
- "content-type": "application/json"
446
- };
447
- b.bp("/alarms/snooze");
448
- let body;
449
- body = JSON.stringify(
450
- (0, import_smithy_client.take)(input, {
451
- snoozeActionRequests: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "snoozeActionRequests")
452
- })
453
- );
454
- b.m("POST").h(headers).b(body);
455
- return b.build();
456
- }, "se_BatchSnoozeAlarmCommand");
457
- var se_BatchUpdateDetectorCommand = /* @__PURE__ */ __name(async (input, context) => {
458
- const b = (0, import_core.requestBuilder)(input, context);
459
- const headers = {
460
- "content-type": "application/json"
461
- };
462
- b.bp("/detectors");
463
- let body;
464
- body = JSON.stringify(
465
- (0, import_smithy_client.take)(input, {
466
- detectors: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "detectors")
467
- })
468
- );
469
- b.m("POST").h(headers).b(body);
470
- return b.build();
471
- }, "se_BatchUpdateDetectorCommand");
472
- var se_DescribeAlarmCommand = /* @__PURE__ */ __name(async (input, context) => {
473
- const b = (0, import_core.requestBuilder)(input, context);
474
- const headers = {};
475
- b.bp("/alarms/{alarmModelName}/keyValues");
476
- b.p("alarmModelName", () => input.alarmModelName, "{alarmModelName}", false);
477
- const query = (0, import_smithy_client.map)({
478
- [_kV]: [, input[_kV]]
479
- });
480
- let body;
481
- b.m("GET").h(headers).q(query).b(body);
482
- return b.build();
483
- }, "se_DescribeAlarmCommand");
484
- var se_DescribeDetectorCommand = /* @__PURE__ */ __name(async (input, context) => {
485
- const b = (0, import_core.requestBuilder)(input, context);
486
- const headers = {};
487
- b.bp("/detectors/{detectorModelName}/keyValues");
488
- b.p("detectorModelName", () => input.detectorModelName, "{detectorModelName}", false);
489
- const query = (0, import_smithy_client.map)({
490
- [_kV]: [, input[_kV]]
491
- });
492
- let body;
493
- b.m("GET").h(headers).q(query).b(body);
494
- return b.build();
495
- }, "se_DescribeDetectorCommand");
496
- var se_ListAlarmsCommand = /* @__PURE__ */ __name(async (input, context) => {
497
- const b = (0, import_core.requestBuilder)(input, context);
498
- const headers = {};
499
- b.bp("/alarms/{alarmModelName}");
500
- b.p("alarmModelName", () => input.alarmModelName, "{alarmModelName}", false);
501
- const query = (0, import_smithy_client.map)({
502
- [_nT]: [, input[_nT]],
503
- [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()]
504
- });
505
- let body;
506
- b.m("GET").h(headers).q(query).b(body);
507
- return b.build();
508
- }, "se_ListAlarmsCommand");
509
- var se_ListDetectorsCommand = /* @__PURE__ */ __name(async (input, context) => {
510
- const b = (0, import_core.requestBuilder)(input, context);
511
- const headers = {};
512
- b.bp("/detectors/{detectorModelName}");
513
- b.p("detectorModelName", () => input.detectorModelName, "{detectorModelName}", false);
514
- const query = (0, import_smithy_client.map)({
515
- [_sN]: [, input[_sN]],
516
- [_nT]: [, input[_nT]],
517
- [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()]
518
- });
519
- let body;
520
- b.m("GET").h(headers).q(query).b(body);
521
- return b.build();
522
- }, "se_ListDetectorsCommand");
523
- var de_BatchAcknowledgeAlarmCommand = /* @__PURE__ */ __name(async (output, context) => {
524
- if (output.statusCode !== 202 && output.statusCode >= 300) {
525
- return de_CommandError(output, context);
526
- }
527
- const contents = (0, import_smithy_client.map)({
528
- $metadata: deserializeMetadata(output)
529
- });
530
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
531
- const doc = (0, import_smithy_client.take)(data, {
532
- errorEntries: import_smithy_client._json
533
- });
534
- Object.assign(contents, doc);
535
- return contents;
536
- }, "de_BatchAcknowledgeAlarmCommand");
537
- var de_BatchDeleteDetectorCommand = /* @__PURE__ */ __name(async (output, context) => {
538
- if (output.statusCode !== 200 && output.statusCode >= 300) {
539
- return de_CommandError(output, context);
540
- }
541
- const contents = (0, import_smithy_client.map)({
542
- $metadata: deserializeMetadata(output)
543
- });
544
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
545
- const doc = (0, import_smithy_client.take)(data, {
546
- batchDeleteDetectorErrorEntries: import_smithy_client._json
547
- });
548
- Object.assign(contents, doc);
549
- return contents;
550
- }, "de_BatchDeleteDetectorCommand");
551
- var de_BatchDisableAlarmCommand = /* @__PURE__ */ __name(async (output, context) => {
552
- if (output.statusCode !== 202 && output.statusCode >= 300) {
553
- return de_CommandError(output, context);
554
- }
555
- const contents = (0, import_smithy_client.map)({
556
- $metadata: deserializeMetadata(output)
557
- });
558
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
559
- const doc = (0, import_smithy_client.take)(data, {
560
- errorEntries: import_smithy_client._json
561
- });
562
- Object.assign(contents, doc);
563
- return contents;
564
- }, "de_BatchDisableAlarmCommand");
565
- var de_BatchEnableAlarmCommand = /* @__PURE__ */ __name(async (output, context) => {
566
- if (output.statusCode !== 202 && output.statusCode >= 300) {
567
- return de_CommandError(output, context);
568
- }
569
- const contents = (0, import_smithy_client.map)({
570
- $metadata: deserializeMetadata(output)
571
- });
572
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
573
- const doc = (0, import_smithy_client.take)(data, {
574
- errorEntries: import_smithy_client._json
575
- });
576
- Object.assign(contents, doc);
577
- return contents;
578
- }, "de_BatchEnableAlarmCommand");
579
- var de_BatchPutMessageCommand = /* @__PURE__ */ __name(async (output, context) => {
580
- if (output.statusCode !== 200 && output.statusCode >= 300) {
581
- return de_CommandError(output, context);
582
- }
583
- const contents = (0, import_smithy_client.map)({
584
- $metadata: deserializeMetadata(output)
585
- });
586
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
587
- const doc = (0, import_smithy_client.take)(data, {
588
- BatchPutMessageErrorEntries: import_smithy_client._json
589
- });
590
- Object.assign(contents, doc);
591
- return contents;
592
- }, "de_BatchPutMessageCommand");
593
- var de_BatchResetAlarmCommand = /* @__PURE__ */ __name(async (output, context) => {
594
- if (output.statusCode !== 202 && output.statusCode >= 300) {
595
- return de_CommandError(output, context);
596
- }
597
- const contents = (0, import_smithy_client.map)({
598
- $metadata: deserializeMetadata(output)
599
- });
600
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
601
- const doc = (0, import_smithy_client.take)(data, {
602
- errorEntries: import_smithy_client._json
603
- });
604
- Object.assign(contents, doc);
605
- return contents;
606
- }, "de_BatchResetAlarmCommand");
607
- var de_BatchSnoozeAlarmCommand = /* @__PURE__ */ __name(async (output, context) => {
608
- if (output.statusCode !== 202 && output.statusCode >= 300) {
609
- return de_CommandError(output, context);
610
- }
611
- const contents = (0, import_smithy_client.map)({
612
- $metadata: deserializeMetadata(output)
613
- });
614
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
615
- const doc = (0, import_smithy_client.take)(data, {
616
- errorEntries: import_smithy_client._json
617
- });
618
- Object.assign(contents, doc);
619
- return contents;
620
- }, "de_BatchSnoozeAlarmCommand");
621
- var de_BatchUpdateDetectorCommand = /* @__PURE__ */ __name(async (output, context) => {
622
- if (output.statusCode !== 200 && output.statusCode >= 300) {
623
- return de_CommandError(output, context);
624
- }
625
- const contents = (0, import_smithy_client.map)({
626
- $metadata: deserializeMetadata(output)
627
- });
628
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
629
- const doc = (0, import_smithy_client.take)(data, {
630
- batchUpdateDetectorErrorEntries: import_smithy_client._json
631
- });
632
- Object.assign(contents, doc);
633
- return contents;
634
- }, "de_BatchUpdateDetectorCommand");
635
- var de_DescribeAlarmCommand = /* @__PURE__ */ __name(async (output, context) => {
636
- if (output.statusCode !== 200 && output.statusCode >= 300) {
637
- return de_CommandError(output, context);
638
- }
639
- const contents = (0, import_smithy_client.map)({
640
- $metadata: deserializeMetadata(output)
641
- });
642
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
643
- const doc = (0, import_smithy_client.take)(data, {
644
- alarm: /* @__PURE__ */ __name((_) => de_Alarm(_, context), "alarm")
645
- });
646
- Object.assign(contents, doc);
647
- return contents;
648
- }, "de_DescribeAlarmCommand");
649
- var de_DescribeDetectorCommand = /* @__PURE__ */ __name(async (output, context) => {
650
- if (output.statusCode !== 200 && output.statusCode >= 300) {
651
- return de_CommandError(output, context);
652
- }
653
- const contents = (0, import_smithy_client.map)({
654
- $metadata: deserializeMetadata(output)
655
- });
656
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
657
- const doc = (0, import_smithy_client.take)(data, {
658
- detector: /* @__PURE__ */ __name((_) => de_Detector(_, context), "detector")
659
- });
660
- Object.assign(contents, doc);
661
- return contents;
662
- }, "de_DescribeDetectorCommand");
663
- var de_ListAlarmsCommand = /* @__PURE__ */ __name(async (output, context) => {
664
- if (output.statusCode !== 200 && output.statusCode >= 300) {
665
- return de_CommandError(output, context);
666
- }
667
- const contents = (0, import_smithy_client.map)({
668
- $metadata: deserializeMetadata(output)
669
- });
670
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
671
- const doc = (0, import_smithy_client.take)(data, {
672
- alarmSummaries: /* @__PURE__ */ __name((_) => de_AlarmSummaries(_, context), "alarmSummaries"),
673
- nextToken: import_smithy_client.expectString
674
- });
675
- Object.assign(contents, doc);
676
- return contents;
677
- }, "de_ListAlarmsCommand");
678
- var de_ListDetectorsCommand = /* @__PURE__ */ __name(async (output, context) => {
679
- if (output.statusCode !== 200 && output.statusCode >= 300) {
680
- return de_CommandError(output, context);
681
- }
682
- const contents = (0, import_smithy_client.map)({
683
- $metadata: deserializeMetadata(output)
684
- });
685
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
686
- const doc = (0, import_smithy_client.take)(data, {
687
- detectorSummaries: /* @__PURE__ */ __name((_) => de_DetectorSummaries(_, context), "detectorSummaries"),
688
- nextToken: import_smithy_client.expectString
689
- });
690
- Object.assign(contents, doc);
691
- return contents;
692
- }, "de_ListDetectorsCommand");
693
- var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
694
- const parsedOutput = {
695
- ...output,
696
- body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
697
- };
698
- const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
699
- switch (errorCode) {
700
- case "InternalFailureException":
701
- case "com.amazonaws.ioteventsdata#InternalFailureException":
702
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
703
- case "InvalidRequestException":
704
- case "com.amazonaws.ioteventsdata#InvalidRequestException":
705
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
706
- case "ServiceUnavailableException":
707
- case "com.amazonaws.ioteventsdata#ServiceUnavailableException":
708
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
709
- case "ThrottlingException":
710
- case "com.amazonaws.ioteventsdata#ThrottlingException":
711
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
712
- case "ResourceNotFoundException":
713
- case "com.amazonaws.ioteventsdata#ResourceNotFoundException":
714
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
715
- default:
716
- const parsedBody = parsedOutput.body;
717
- return throwDefaultError({
718
- output,
719
- parsedBody,
720
- errorCode
721
- });
722
- }
723
- }, "de_CommandError");
724
- var throwDefaultError = (0, import_smithy_client.withBaseException)(IoTEventsDataServiceException);
725
- var de_InternalFailureExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
726
- const contents = (0, import_smithy_client.map)({});
727
- const data = parsedOutput.body;
728
- const doc = (0, import_smithy_client.take)(data, {
729
- message: import_smithy_client.expectString
730
- });
731
- Object.assign(contents, doc);
732
- const exception = new InternalFailureException({
733
- $metadata: deserializeMetadata(parsedOutput),
734
- ...contents
735
- });
736
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
737
- }, "de_InternalFailureExceptionRes");
738
- var de_InvalidRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
739
- const contents = (0, import_smithy_client.map)({});
740
- const data = parsedOutput.body;
741
- const doc = (0, import_smithy_client.take)(data, {
742
- message: import_smithy_client.expectString
743
- });
744
- Object.assign(contents, doc);
745
- const exception = new InvalidRequestException({
746
- $metadata: deserializeMetadata(parsedOutput),
747
- ...contents
748
- });
749
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
750
- }, "de_InvalidRequestExceptionRes");
751
- var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
752
- const contents = (0, import_smithy_client.map)({});
753
- const data = parsedOutput.body;
754
- const doc = (0, import_smithy_client.take)(data, {
755
- message: import_smithy_client.expectString
756
- });
757
- Object.assign(contents, doc);
758
- const exception = new ResourceNotFoundException({
759
- $metadata: deserializeMetadata(parsedOutput),
760
- ...contents
761
- });
762
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
763
- }, "de_ResourceNotFoundExceptionRes");
764
- var de_ServiceUnavailableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
765
- const contents = (0, import_smithy_client.map)({});
766
- const data = parsedOutput.body;
767
- const doc = (0, import_smithy_client.take)(data, {
768
- message: import_smithy_client.expectString
769
- });
770
- Object.assign(contents, doc);
771
- const exception = new ServiceUnavailableException({
772
- $metadata: deserializeMetadata(parsedOutput),
773
- ...contents
774
- });
775
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
776
- }, "de_ServiceUnavailableExceptionRes");
777
- var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
778
- const contents = (0, import_smithy_client.map)({});
779
- const data = parsedOutput.body;
780
- const doc = (0, import_smithy_client.take)(data, {
781
- message: import_smithy_client.expectString
782
- });
783
- Object.assign(contents, doc);
784
- const exception = new ThrottlingException({
785
- $metadata: deserializeMetadata(parsedOutput),
786
- ...contents
787
- });
788
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
789
- }, "de_ThrottlingExceptionRes");
790
- var se_Message = /* @__PURE__ */ __name((input, context) => {
791
- return (0, import_smithy_client.take)(input, {
792
- inputName: [],
793
- messageId: [],
794
- payload: context.base64Encoder,
795
- timestamp: import_smithy_client._json
796
- });
797
- }, "se_Message");
798
- var se_Messages = /* @__PURE__ */ __name((input, context) => {
799
- return input.filter((e) => e != null).map((entry) => {
800
- return se_Message(entry, context);
801
- });
802
- }, "se_Messages");
803
- var de_Alarm = /* @__PURE__ */ __name((output, context) => {
804
- return (0, import_smithy_client.take)(output, {
805
- alarmModelName: import_smithy_client.expectString,
806
- alarmModelVersion: import_smithy_client.expectString,
807
- alarmState: import_smithy_client._json,
808
- creationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "creationTime"),
809
- keyValue: import_smithy_client.expectString,
810
- lastUpdateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "lastUpdateTime"),
811
- severity: import_smithy_client.expectInt32
812
- });
813
- }, "de_Alarm");
814
- var de_AlarmSummaries = /* @__PURE__ */ __name((output, context) => {
815
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
816
- return de_AlarmSummary(entry, context);
817
- });
818
- return retVal;
819
- }, "de_AlarmSummaries");
820
- var de_AlarmSummary = /* @__PURE__ */ __name((output, context) => {
821
- return (0, import_smithy_client.take)(output, {
822
- alarmModelName: import_smithy_client.expectString,
823
- alarmModelVersion: import_smithy_client.expectString,
824
- creationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "creationTime"),
825
- keyValue: import_smithy_client.expectString,
826
- lastUpdateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "lastUpdateTime"),
827
- stateName: import_smithy_client.expectString
828
- });
829
- }, "de_AlarmSummary");
830
- var de_Detector = /* @__PURE__ */ __name((output, context) => {
831
- return (0, import_smithy_client.take)(output, {
832
- creationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "creationTime"),
833
- detectorModelName: import_smithy_client.expectString,
834
- detectorModelVersion: import_smithy_client.expectString,
835
- keyValue: import_smithy_client.expectString,
836
- lastUpdateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "lastUpdateTime"),
837
- state: /* @__PURE__ */ __name((_) => de_DetectorState(_, context), "state")
838
- });
839
- }, "de_Detector");
840
- var de_DetectorState = /* @__PURE__ */ __name((output, context) => {
841
- return (0, import_smithy_client.take)(output, {
842
- stateName: import_smithy_client.expectString,
843
- timers: /* @__PURE__ */ __name((_) => de_Timers(_, context), "timers"),
844
- variables: import_smithy_client._json
845
- });
846
- }, "de_DetectorState");
847
- var de_DetectorSummaries = /* @__PURE__ */ __name((output, context) => {
848
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
849
- return de_DetectorSummary(entry, context);
850
- });
851
- return retVal;
852
- }, "de_DetectorSummaries");
853
- var de_DetectorSummary = /* @__PURE__ */ __name((output, context) => {
854
- return (0, import_smithy_client.take)(output, {
855
- creationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "creationTime"),
856
- detectorModelName: import_smithy_client.expectString,
857
- detectorModelVersion: import_smithy_client.expectString,
858
- keyValue: import_smithy_client.expectString,
859
- lastUpdateTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "lastUpdateTime"),
860
- state: import_smithy_client._json
861
- });
862
- }, "de_DetectorSummary");
863
- var de_Timer = /* @__PURE__ */ __name((output, context) => {
864
- return (0, import_smithy_client.take)(output, {
865
- name: import_smithy_client.expectString,
866
- timestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "timestamp")
867
- });
868
- }, "de_Timer");
869
- var de_Timers = /* @__PURE__ */ __name((output, context) => {
870
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
871
- return de_Timer(entry, context);
872
- });
873
- return retVal;
874
- }, "de_Timers");
875
- var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
876
- httpStatusCode: output.statusCode,
877
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
878
- extendedRequestId: output.headers["x-amz-id-2"],
879
- cfId: output.headers["x-amz-cf-id"]
880
- }), "deserializeMetadata");
881
- var _kV = "keyValue";
882
- var _mR = "maxResults";
883
- var _nT = "nextToken";
884
- var _sN = "stateName";
885
-
886
- // src/commands/BatchAcknowledgeAlarmCommand.ts
887
- var BatchAcknowledgeAlarmCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
888
- return [
889
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
890
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
891
- ];
892
- }).s("IotColumboDataService", "BatchAcknowledgeAlarm", {}).n("IoTEventsDataClient", "BatchAcknowledgeAlarmCommand").f(void 0, void 0).ser(se_BatchAcknowledgeAlarmCommand).de(de_BatchAcknowledgeAlarmCommand).build() {
893
- static {
894
- __name(this, "BatchAcknowledgeAlarmCommand");
895
- }
386
+ const de_BatchDeleteDetectorCommand = async (output, context) => {
387
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
388
+ return de_CommandError(output, context);
389
+ }
390
+ const contents = smithyClient.map({
391
+ $metadata: deserializeMetadata(output),
392
+ });
393
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
394
+ const doc = smithyClient.take(data, {
395
+ batchDeleteDetectorErrorEntries: smithyClient._json,
396
+ });
397
+ Object.assign(contents, doc);
398
+ return contents;
896
399
  };
897
-
898
- // src/commands/BatchDeleteDetectorCommand.ts
899
-
900
-
901
-
902
- var BatchDeleteDetectorCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
903
- return [
904
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
905
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
906
- ];
907
- }).s("IotColumboDataService", "BatchDeleteDetector", {}).n("IoTEventsDataClient", "BatchDeleteDetectorCommand").f(void 0, void 0).ser(se_BatchDeleteDetectorCommand).de(de_BatchDeleteDetectorCommand).build() {
908
- static {
909
- __name(this, "BatchDeleteDetectorCommand");
910
- }
400
+ const de_BatchDisableAlarmCommand = async (output, context) => {
401
+ if (output.statusCode !== 202 && output.statusCode >= 300) {
402
+ return de_CommandError(output, context);
403
+ }
404
+ const contents = smithyClient.map({
405
+ $metadata: deserializeMetadata(output),
406
+ });
407
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
408
+ const doc = smithyClient.take(data, {
409
+ errorEntries: smithyClient._json,
410
+ });
411
+ Object.assign(contents, doc);
412
+ return contents;
911
413
  };
912
-
913
- // src/commands/BatchDisableAlarmCommand.ts
914
-
915
-
916
-
917
- var BatchDisableAlarmCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
918
- return [
919
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
920
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
921
- ];
922
- }).s("IotColumboDataService", "BatchDisableAlarm", {}).n("IoTEventsDataClient", "BatchDisableAlarmCommand").f(void 0, void 0).ser(se_BatchDisableAlarmCommand).de(de_BatchDisableAlarmCommand).build() {
923
- static {
924
- __name(this, "BatchDisableAlarmCommand");
925
- }
414
+ const de_BatchEnableAlarmCommand = async (output, context) => {
415
+ if (output.statusCode !== 202 && output.statusCode >= 300) {
416
+ return de_CommandError(output, context);
417
+ }
418
+ const contents = smithyClient.map({
419
+ $metadata: deserializeMetadata(output),
420
+ });
421
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
422
+ const doc = smithyClient.take(data, {
423
+ errorEntries: smithyClient._json,
424
+ });
425
+ Object.assign(contents, doc);
426
+ return contents;
926
427
  };
927
-
928
- // src/commands/BatchEnableAlarmCommand.ts
929
-
930
-
931
-
932
- var BatchEnableAlarmCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
933
- return [
934
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
935
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
936
- ];
937
- }).s("IotColumboDataService", "BatchEnableAlarm", {}).n("IoTEventsDataClient", "BatchEnableAlarmCommand").f(void 0, void 0).ser(se_BatchEnableAlarmCommand).de(de_BatchEnableAlarmCommand).build() {
938
- static {
939
- __name(this, "BatchEnableAlarmCommand");
940
- }
428
+ const de_BatchPutMessageCommand = async (output, context) => {
429
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
430
+ return de_CommandError(output, context);
431
+ }
432
+ const contents = smithyClient.map({
433
+ $metadata: deserializeMetadata(output),
434
+ });
435
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
436
+ const doc = smithyClient.take(data, {
437
+ BatchPutMessageErrorEntries: smithyClient._json,
438
+ });
439
+ Object.assign(contents, doc);
440
+ return contents;
941
441
  };
942
-
943
- // src/commands/BatchPutMessageCommand.ts
944
-
945
-
946
-
947
- var BatchPutMessageCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
948
- return [
949
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
950
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
951
- ];
952
- }).s("IotColumboDataService", "BatchPutMessage", {}).n("IoTEventsDataClient", "BatchPutMessageCommand").f(void 0, void 0).ser(se_BatchPutMessageCommand).de(de_BatchPutMessageCommand).build() {
953
- static {
954
- __name(this, "BatchPutMessageCommand");
955
- }
442
+ const de_BatchResetAlarmCommand = async (output, context) => {
443
+ if (output.statusCode !== 202 && output.statusCode >= 300) {
444
+ return de_CommandError(output, context);
445
+ }
446
+ const contents = smithyClient.map({
447
+ $metadata: deserializeMetadata(output),
448
+ });
449
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
450
+ const doc = smithyClient.take(data, {
451
+ errorEntries: smithyClient._json,
452
+ });
453
+ Object.assign(contents, doc);
454
+ return contents;
956
455
  };
957
-
958
- // src/commands/BatchResetAlarmCommand.ts
959
-
960
-
961
-
962
- var BatchResetAlarmCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
963
- return [
964
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
965
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
966
- ];
967
- }).s("IotColumboDataService", "BatchResetAlarm", {}).n("IoTEventsDataClient", "BatchResetAlarmCommand").f(void 0, void 0).ser(se_BatchResetAlarmCommand).de(de_BatchResetAlarmCommand).build() {
968
- static {
969
- __name(this, "BatchResetAlarmCommand");
970
- }
456
+ const de_BatchSnoozeAlarmCommand = async (output, context) => {
457
+ if (output.statusCode !== 202 && output.statusCode >= 300) {
458
+ return de_CommandError(output, context);
459
+ }
460
+ const contents = smithyClient.map({
461
+ $metadata: deserializeMetadata(output),
462
+ });
463
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
464
+ const doc = smithyClient.take(data, {
465
+ errorEntries: smithyClient._json,
466
+ });
467
+ Object.assign(contents, doc);
468
+ return contents;
971
469
  };
972
-
973
- // src/commands/BatchSnoozeAlarmCommand.ts
974
-
975
-
976
-
977
- var BatchSnoozeAlarmCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
978
- return [
979
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
980
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
981
- ];
982
- }).s("IotColumboDataService", "BatchSnoozeAlarm", {}).n("IoTEventsDataClient", "BatchSnoozeAlarmCommand").f(void 0, void 0).ser(se_BatchSnoozeAlarmCommand).de(de_BatchSnoozeAlarmCommand).build() {
983
- static {
984
- __name(this, "BatchSnoozeAlarmCommand");
985
- }
470
+ const de_BatchUpdateDetectorCommand = async (output, context) => {
471
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
472
+ return de_CommandError(output, context);
473
+ }
474
+ const contents = smithyClient.map({
475
+ $metadata: deserializeMetadata(output),
476
+ });
477
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
478
+ const doc = smithyClient.take(data, {
479
+ batchUpdateDetectorErrorEntries: smithyClient._json,
480
+ });
481
+ Object.assign(contents, doc);
482
+ return contents;
986
483
  };
987
-
988
- // src/commands/BatchUpdateDetectorCommand.ts
989
-
990
-
991
-
992
- var BatchUpdateDetectorCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
993
- return [
994
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
995
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
996
- ];
997
- }).s("IotColumboDataService", "BatchUpdateDetector", {}).n("IoTEventsDataClient", "BatchUpdateDetectorCommand").f(void 0, void 0).ser(se_BatchUpdateDetectorCommand).de(de_BatchUpdateDetectorCommand).build() {
998
- static {
999
- __name(this, "BatchUpdateDetectorCommand");
1000
- }
484
+ const de_DescribeAlarmCommand = async (output, context) => {
485
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
486
+ return de_CommandError(output, context);
487
+ }
488
+ const contents = smithyClient.map({
489
+ $metadata: deserializeMetadata(output),
490
+ });
491
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
492
+ const doc = smithyClient.take(data, {
493
+ alarm: (_) => de_Alarm(_),
494
+ });
495
+ Object.assign(contents, doc);
496
+ return contents;
1001
497
  };
1002
-
1003
- // src/commands/DescribeAlarmCommand.ts
1004
-
1005
-
1006
-
1007
- var DescribeAlarmCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1008
- return [
1009
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1010
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1011
- ];
1012
- }).s("IotColumboDataService", "DescribeAlarm", {}).n("IoTEventsDataClient", "DescribeAlarmCommand").f(void 0, void 0).ser(se_DescribeAlarmCommand).de(de_DescribeAlarmCommand).build() {
1013
- static {
1014
- __name(this, "DescribeAlarmCommand");
1015
- }
498
+ const de_DescribeDetectorCommand = async (output, context) => {
499
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
500
+ return de_CommandError(output, context);
501
+ }
502
+ const contents = smithyClient.map({
503
+ $metadata: deserializeMetadata(output),
504
+ });
505
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
506
+ const doc = smithyClient.take(data, {
507
+ detector: (_) => de_Detector(_),
508
+ });
509
+ Object.assign(contents, doc);
510
+ return contents;
1016
511
  };
1017
-
1018
- // src/commands/DescribeDetectorCommand.ts
1019
-
1020
-
1021
-
1022
- var DescribeDetectorCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1023
- return [
1024
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1025
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1026
- ];
1027
- }).s("IotColumboDataService", "DescribeDetector", {}).n("IoTEventsDataClient", "DescribeDetectorCommand").f(void 0, void 0).ser(se_DescribeDetectorCommand).de(de_DescribeDetectorCommand).build() {
1028
- static {
1029
- __name(this, "DescribeDetectorCommand");
1030
- }
512
+ const de_ListAlarmsCommand = async (output, context) => {
513
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
514
+ return de_CommandError(output, context);
515
+ }
516
+ const contents = smithyClient.map({
517
+ $metadata: deserializeMetadata(output),
518
+ });
519
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
520
+ const doc = smithyClient.take(data, {
521
+ alarmSummaries: (_) => de_AlarmSummaries(_),
522
+ nextToken: smithyClient.expectString,
523
+ });
524
+ Object.assign(contents, doc);
525
+ return contents;
1031
526
  };
1032
-
1033
- // src/commands/ListAlarmsCommand.ts
1034
-
1035
-
1036
-
1037
- var ListAlarmsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1038
- return [
1039
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1040
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1041
- ];
1042
- }).s("IotColumboDataService", "ListAlarms", {}).n("IoTEventsDataClient", "ListAlarmsCommand").f(void 0, void 0).ser(se_ListAlarmsCommand).de(de_ListAlarmsCommand).build() {
1043
- static {
1044
- __name(this, "ListAlarmsCommand");
1045
- }
527
+ const de_ListDetectorsCommand = async (output, context) => {
528
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
529
+ return de_CommandError(output, context);
530
+ }
531
+ const contents = smithyClient.map({
532
+ $metadata: deserializeMetadata(output),
533
+ });
534
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
535
+ const doc = smithyClient.take(data, {
536
+ detectorSummaries: (_) => de_DetectorSummaries(_),
537
+ nextToken: smithyClient.expectString,
538
+ });
539
+ Object.assign(contents, doc);
540
+ return contents;
1046
541
  };
1047
-
1048
- // src/commands/ListDetectorsCommand.ts
1049
-
1050
-
1051
-
1052
- var ListDetectorsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1053
- return [
1054
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1055
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1056
- ];
1057
- }).s("IotColumboDataService", "ListDetectors", {}).n("IoTEventsDataClient", "ListDetectorsCommand").f(void 0, void 0).ser(se_ListDetectorsCommand).de(de_ListDetectorsCommand).build() {
1058
- static {
1059
- __name(this, "ListDetectorsCommand");
1060
- }
542
+ const de_CommandError = async (output, context) => {
543
+ const parsedOutput = {
544
+ ...output,
545
+ body: await core$1.parseJsonErrorBody(output.body, context),
546
+ };
547
+ const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
548
+ switch (errorCode) {
549
+ case "InternalFailureException":
550
+ case "com.amazonaws.ioteventsdata#InternalFailureException":
551
+ throw await de_InternalFailureExceptionRes(parsedOutput);
552
+ case "InvalidRequestException":
553
+ case "com.amazonaws.ioteventsdata#InvalidRequestException":
554
+ throw await de_InvalidRequestExceptionRes(parsedOutput);
555
+ case "ServiceUnavailableException":
556
+ case "com.amazonaws.ioteventsdata#ServiceUnavailableException":
557
+ throw await de_ServiceUnavailableExceptionRes(parsedOutput);
558
+ case "ThrottlingException":
559
+ case "com.amazonaws.ioteventsdata#ThrottlingException":
560
+ throw await de_ThrottlingExceptionRes(parsedOutput);
561
+ case "ResourceNotFoundException":
562
+ case "com.amazonaws.ioteventsdata#ResourceNotFoundException":
563
+ throw await de_ResourceNotFoundExceptionRes(parsedOutput);
564
+ default:
565
+ const parsedBody = parsedOutput.body;
566
+ return throwDefaultError({
567
+ output,
568
+ parsedBody,
569
+ errorCode,
570
+ });
571
+ }
1061
572
  };
1062
-
1063
- // src/IoTEventsData.ts
1064
- var commands = {
1065
- BatchAcknowledgeAlarmCommand,
1066
- BatchDeleteDetectorCommand,
1067
- BatchDisableAlarmCommand,
1068
- BatchEnableAlarmCommand,
1069
- BatchPutMessageCommand,
1070
- BatchResetAlarmCommand,
1071
- BatchSnoozeAlarmCommand,
1072
- BatchUpdateDetectorCommand,
1073
- DescribeAlarmCommand,
1074
- DescribeDetectorCommand,
1075
- ListAlarmsCommand,
1076
- ListDetectorsCommand
573
+ const throwDefaultError = smithyClient.withBaseException(IoTEventsDataServiceException);
574
+ const de_InternalFailureExceptionRes = async (parsedOutput, context) => {
575
+ const contents = smithyClient.map({});
576
+ const data = parsedOutput.body;
577
+ const doc = smithyClient.take(data, {
578
+ message: smithyClient.expectString,
579
+ });
580
+ Object.assign(contents, doc);
581
+ const exception = new InternalFailureException({
582
+ $metadata: deserializeMetadata(parsedOutput),
583
+ ...contents,
584
+ });
585
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1077
586
  };
1078
- var IoTEventsData = class extends IoTEventsDataClient {
1079
- static {
1080
- __name(this, "IoTEventsData");
1081
- }
587
+ const de_InvalidRequestExceptionRes = async (parsedOutput, context) => {
588
+ const contents = smithyClient.map({});
589
+ const data = parsedOutput.body;
590
+ const doc = smithyClient.take(data, {
591
+ message: smithyClient.expectString,
592
+ });
593
+ Object.assign(contents, doc);
594
+ const exception = new InvalidRequestException({
595
+ $metadata: deserializeMetadata(parsedOutput),
596
+ ...contents,
597
+ });
598
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1082
599
  };
1083
- (0, import_smithy_client.createAggregatedClient)(commands, IoTEventsData);
1084
- // Annotate the CommonJS export names for ESM import in node:
1085
-
1086
- 0 && (module.exports = {
1087
- IoTEventsDataServiceException,
1088
- __Client,
1089
- IoTEventsDataClient,
1090
- IoTEventsData,
1091
- $Command,
1092
- BatchAcknowledgeAlarmCommand,
1093
- BatchDeleteDetectorCommand,
1094
- BatchDisableAlarmCommand,
1095
- BatchEnableAlarmCommand,
1096
- BatchPutMessageCommand,
1097
- BatchResetAlarmCommand,
1098
- BatchSnoozeAlarmCommand,
1099
- BatchUpdateDetectorCommand,
1100
- DescribeAlarmCommand,
1101
- DescribeDetectorCommand,
1102
- ListAlarmsCommand,
1103
- ListDetectorsCommand,
1104
- CustomerActionName,
1105
- ComparisonOperator,
1106
- AlarmStateName,
1107
- EventType,
1108
- TriggerType,
1109
- ErrorCode,
1110
- InternalFailureException,
1111
- InvalidRequestException,
1112
- ServiceUnavailableException,
1113
- ThrottlingException,
1114
- ResourceNotFoundException
600
+ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
601
+ const contents = smithyClient.map({});
602
+ const data = parsedOutput.body;
603
+ const doc = smithyClient.take(data, {
604
+ message: smithyClient.expectString,
605
+ });
606
+ Object.assign(contents, doc);
607
+ const exception = new ResourceNotFoundException({
608
+ $metadata: deserializeMetadata(parsedOutput),
609
+ ...contents,
610
+ });
611
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
612
+ };
613
+ const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
614
+ const contents = smithyClient.map({});
615
+ const data = parsedOutput.body;
616
+ const doc = smithyClient.take(data, {
617
+ message: smithyClient.expectString,
618
+ });
619
+ Object.assign(contents, doc);
620
+ const exception = new ServiceUnavailableException({
621
+ $metadata: deserializeMetadata(parsedOutput),
622
+ ...contents,
623
+ });
624
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
625
+ };
626
+ const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
627
+ const contents = smithyClient.map({});
628
+ const data = parsedOutput.body;
629
+ const doc = smithyClient.take(data, {
630
+ message: smithyClient.expectString,
631
+ });
632
+ Object.assign(contents, doc);
633
+ const exception = new ThrottlingException({
634
+ $metadata: deserializeMetadata(parsedOutput),
635
+ ...contents,
636
+ });
637
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
638
+ };
639
+ const se_Message = (input, context) => {
640
+ return smithyClient.take(input, {
641
+ inputName: [],
642
+ messageId: [],
643
+ payload: context.base64Encoder,
644
+ timestamp: smithyClient._json,
645
+ });
646
+ };
647
+ const se_Messages = (input, context) => {
648
+ return input
649
+ .filter((e) => e != null)
650
+ .map((entry) => {
651
+ return se_Message(entry, context);
652
+ });
653
+ };
654
+ const de_Alarm = (output, context) => {
655
+ return smithyClient.take(output, {
656
+ alarmModelName: smithyClient.expectString,
657
+ alarmModelVersion: smithyClient.expectString,
658
+ alarmState: smithyClient._json,
659
+ creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
660
+ keyValue: smithyClient.expectString,
661
+ lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
662
+ severity: smithyClient.expectInt32,
663
+ });
664
+ };
665
+ const de_AlarmSummaries = (output, context) => {
666
+ const retVal = (output || [])
667
+ .filter((e) => e != null)
668
+ .map((entry) => {
669
+ return de_AlarmSummary(entry);
670
+ });
671
+ return retVal;
672
+ };
673
+ const de_AlarmSummary = (output, context) => {
674
+ return smithyClient.take(output, {
675
+ alarmModelName: smithyClient.expectString,
676
+ alarmModelVersion: smithyClient.expectString,
677
+ creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
678
+ keyValue: smithyClient.expectString,
679
+ lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
680
+ stateName: smithyClient.expectString,
681
+ });
682
+ };
683
+ const de_Detector = (output, context) => {
684
+ return smithyClient.take(output, {
685
+ creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
686
+ detectorModelName: smithyClient.expectString,
687
+ detectorModelVersion: smithyClient.expectString,
688
+ keyValue: smithyClient.expectString,
689
+ lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
690
+ state: (_) => de_DetectorState(_),
691
+ });
692
+ };
693
+ const de_DetectorState = (output, context) => {
694
+ return smithyClient.take(output, {
695
+ stateName: smithyClient.expectString,
696
+ timers: (_) => de_Timers(_),
697
+ variables: smithyClient._json,
698
+ });
699
+ };
700
+ const de_DetectorSummaries = (output, context) => {
701
+ const retVal = (output || [])
702
+ .filter((e) => e != null)
703
+ .map((entry) => {
704
+ return de_DetectorSummary(entry);
705
+ });
706
+ return retVal;
707
+ };
708
+ const de_DetectorSummary = (output, context) => {
709
+ return smithyClient.take(output, {
710
+ creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
711
+ detectorModelName: smithyClient.expectString,
712
+ detectorModelVersion: smithyClient.expectString,
713
+ keyValue: smithyClient.expectString,
714
+ lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
715
+ state: smithyClient._json,
716
+ });
717
+ };
718
+ const de_Timer = (output, context) => {
719
+ return smithyClient.take(output, {
720
+ name: smithyClient.expectString,
721
+ timestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
722
+ });
723
+ };
724
+ const de_Timers = (output, context) => {
725
+ const retVal = (output || [])
726
+ .filter((e) => e != null)
727
+ .map((entry) => {
728
+ return de_Timer(entry);
729
+ });
730
+ return retVal;
731
+ };
732
+ const deserializeMetadata = (output) => ({
733
+ httpStatusCode: output.statusCode,
734
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
735
+ extendedRequestId: output.headers["x-amz-id-2"],
736
+ cfId: output.headers["x-amz-cf-id"],
1115
737
  });
738
+ const _kV = "keyValue";
739
+ const _mR = "maxResults";
740
+ const _nT = "nextToken";
741
+ const _sN = "stateName";
742
+
743
+ class BatchAcknowledgeAlarmCommand extends smithyClient.Command
744
+ .classBuilder()
745
+ .ep(commonParams)
746
+ .m(function (Command, cs, config, o) {
747
+ return [
748
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
749
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
750
+ ];
751
+ })
752
+ .s("IotColumboDataService", "BatchAcknowledgeAlarm", {})
753
+ .n("IoTEventsDataClient", "BatchAcknowledgeAlarmCommand")
754
+ .f(void 0, void 0)
755
+ .ser(se_BatchAcknowledgeAlarmCommand)
756
+ .de(de_BatchAcknowledgeAlarmCommand)
757
+ .build() {
758
+ }
759
+
760
+ class BatchDeleteDetectorCommand extends smithyClient.Command
761
+ .classBuilder()
762
+ .ep(commonParams)
763
+ .m(function (Command, cs, config, o) {
764
+ return [
765
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
766
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
767
+ ];
768
+ })
769
+ .s("IotColumboDataService", "BatchDeleteDetector", {})
770
+ .n("IoTEventsDataClient", "BatchDeleteDetectorCommand")
771
+ .f(void 0, void 0)
772
+ .ser(se_BatchDeleteDetectorCommand)
773
+ .de(de_BatchDeleteDetectorCommand)
774
+ .build() {
775
+ }
776
+
777
+ class BatchDisableAlarmCommand extends smithyClient.Command
778
+ .classBuilder()
779
+ .ep(commonParams)
780
+ .m(function (Command, cs, config, o) {
781
+ return [
782
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
783
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
784
+ ];
785
+ })
786
+ .s("IotColumboDataService", "BatchDisableAlarm", {})
787
+ .n("IoTEventsDataClient", "BatchDisableAlarmCommand")
788
+ .f(void 0, void 0)
789
+ .ser(se_BatchDisableAlarmCommand)
790
+ .de(de_BatchDisableAlarmCommand)
791
+ .build() {
792
+ }
793
+
794
+ class BatchEnableAlarmCommand extends smithyClient.Command
795
+ .classBuilder()
796
+ .ep(commonParams)
797
+ .m(function (Command, cs, config, o) {
798
+ return [
799
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
800
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
801
+ ];
802
+ })
803
+ .s("IotColumboDataService", "BatchEnableAlarm", {})
804
+ .n("IoTEventsDataClient", "BatchEnableAlarmCommand")
805
+ .f(void 0, void 0)
806
+ .ser(se_BatchEnableAlarmCommand)
807
+ .de(de_BatchEnableAlarmCommand)
808
+ .build() {
809
+ }
810
+
811
+ class BatchPutMessageCommand extends smithyClient.Command
812
+ .classBuilder()
813
+ .ep(commonParams)
814
+ .m(function (Command, cs, config, o) {
815
+ return [
816
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
817
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
818
+ ];
819
+ })
820
+ .s("IotColumboDataService", "BatchPutMessage", {})
821
+ .n("IoTEventsDataClient", "BatchPutMessageCommand")
822
+ .f(void 0, void 0)
823
+ .ser(se_BatchPutMessageCommand)
824
+ .de(de_BatchPutMessageCommand)
825
+ .build() {
826
+ }
827
+
828
+ class BatchResetAlarmCommand extends smithyClient.Command
829
+ .classBuilder()
830
+ .ep(commonParams)
831
+ .m(function (Command, cs, config, o) {
832
+ return [
833
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
834
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
835
+ ];
836
+ })
837
+ .s("IotColumboDataService", "BatchResetAlarm", {})
838
+ .n("IoTEventsDataClient", "BatchResetAlarmCommand")
839
+ .f(void 0, void 0)
840
+ .ser(se_BatchResetAlarmCommand)
841
+ .de(de_BatchResetAlarmCommand)
842
+ .build() {
843
+ }
844
+
845
+ class BatchSnoozeAlarmCommand extends smithyClient.Command
846
+ .classBuilder()
847
+ .ep(commonParams)
848
+ .m(function (Command, cs, config, o) {
849
+ return [
850
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
851
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
852
+ ];
853
+ })
854
+ .s("IotColumboDataService", "BatchSnoozeAlarm", {})
855
+ .n("IoTEventsDataClient", "BatchSnoozeAlarmCommand")
856
+ .f(void 0, void 0)
857
+ .ser(se_BatchSnoozeAlarmCommand)
858
+ .de(de_BatchSnoozeAlarmCommand)
859
+ .build() {
860
+ }
861
+
862
+ class BatchUpdateDetectorCommand extends smithyClient.Command
863
+ .classBuilder()
864
+ .ep(commonParams)
865
+ .m(function (Command, cs, config, o) {
866
+ return [
867
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
868
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
869
+ ];
870
+ })
871
+ .s("IotColumboDataService", "BatchUpdateDetector", {})
872
+ .n("IoTEventsDataClient", "BatchUpdateDetectorCommand")
873
+ .f(void 0, void 0)
874
+ .ser(se_BatchUpdateDetectorCommand)
875
+ .de(de_BatchUpdateDetectorCommand)
876
+ .build() {
877
+ }
878
+
879
+ class DescribeAlarmCommand extends smithyClient.Command
880
+ .classBuilder()
881
+ .ep(commonParams)
882
+ .m(function (Command, cs, config, o) {
883
+ return [
884
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
885
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
886
+ ];
887
+ })
888
+ .s("IotColumboDataService", "DescribeAlarm", {})
889
+ .n("IoTEventsDataClient", "DescribeAlarmCommand")
890
+ .f(void 0, void 0)
891
+ .ser(se_DescribeAlarmCommand)
892
+ .de(de_DescribeAlarmCommand)
893
+ .build() {
894
+ }
895
+
896
+ class DescribeDetectorCommand extends smithyClient.Command
897
+ .classBuilder()
898
+ .ep(commonParams)
899
+ .m(function (Command, cs, config, o) {
900
+ return [
901
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
902
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
903
+ ];
904
+ })
905
+ .s("IotColumboDataService", "DescribeDetector", {})
906
+ .n("IoTEventsDataClient", "DescribeDetectorCommand")
907
+ .f(void 0, void 0)
908
+ .ser(se_DescribeDetectorCommand)
909
+ .de(de_DescribeDetectorCommand)
910
+ .build() {
911
+ }
912
+
913
+ class ListAlarmsCommand extends smithyClient.Command
914
+ .classBuilder()
915
+ .ep(commonParams)
916
+ .m(function (Command, cs, config, o) {
917
+ return [
918
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
919
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
920
+ ];
921
+ })
922
+ .s("IotColumboDataService", "ListAlarms", {})
923
+ .n("IoTEventsDataClient", "ListAlarmsCommand")
924
+ .f(void 0, void 0)
925
+ .ser(se_ListAlarmsCommand)
926
+ .de(de_ListAlarmsCommand)
927
+ .build() {
928
+ }
929
+
930
+ class ListDetectorsCommand extends smithyClient.Command
931
+ .classBuilder()
932
+ .ep(commonParams)
933
+ .m(function (Command, cs, config, o) {
934
+ return [
935
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
936
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
937
+ ];
938
+ })
939
+ .s("IotColumboDataService", "ListDetectors", {})
940
+ .n("IoTEventsDataClient", "ListDetectorsCommand")
941
+ .f(void 0, void 0)
942
+ .ser(se_ListDetectorsCommand)
943
+ .de(de_ListDetectorsCommand)
944
+ .build() {
945
+ }
946
+
947
+ const commands = {
948
+ BatchAcknowledgeAlarmCommand,
949
+ BatchDeleteDetectorCommand,
950
+ BatchDisableAlarmCommand,
951
+ BatchEnableAlarmCommand,
952
+ BatchPutMessageCommand,
953
+ BatchResetAlarmCommand,
954
+ BatchSnoozeAlarmCommand,
955
+ BatchUpdateDetectorCommand,
956
+ DescribeAlarmCommand,
957
+ DescribeDetectorCommand,
958
+ ListAlarmsCommand,
959
+ ListDetectorsCommand,
960
+ };
961
+ class IoTEventsData extends IoTEventsDataClient {
962
+ }
963
+ smithyClient.createAggregatedClient(commands, IoTEventsData);
1116
964
 
965
+ Object.defineProperty(exports, "$Command", {
966
+ enumerable: true,
967
+ get: function () { return smithyClient.Command; }
968
+ });
969
+ Object.defineProperty(exports, "__Client", {
970
+ enumerable: true,
971
+ get: function () { return smithyClient.Client; }
972
+ });
973
+ exports.AlarmStateName = AlarmStateName;
974
+ exports.BatchAcknowledgeAlarmCommand = BatchAcknowledgeAlarmCommand;
975
+ exports.BatchDeleteDetectorCommand = BatchDeleteDetectorCommand;
976
+ exports.BatchDisableAlarmCommand = BatchDisableAlarmCommand;
977
+ exports.BatchEnableAlarmCommand = BatchEnableAlarmCommand;
978
+ exports.BatchPutMessageCommand = BatchPutMessageCommand;
979
+ exports.BatchResetAlarmCommand = BatchResetAlarmCommand;
980
+ exports.BatchSnoozeAlarmCommand = BatchSnoozeAlarmCommand;
981
+ exports.BatchUpdateDetectorCommand = BatchUpdateDetectorCommand;
982
+ exports.ComparisonOperator = ComparisonOperator;
983
+ exports.CustomerActionName = CustomerActionName;
984
+ exports.DescribeAlarmCommand = DescribeAlarmCommand;
985
+ exports.DescribeDetectorCommand = DescribeDetectorCommand;
986
+ exports.ErrorCode = ErrorCode;
987
+ exports.EventType = EventType;
988
+ exports.InternalFailureException = InternalFailureException;
989
+ exports.InvalidRequestException = InvalidRequestException;
990
+ exports.IoTEventsData = IoTEventsData;
991
+ exports.IoTEventsDataClient = IoTEventsDataClient;
992
+ exports.IoTEventsDataServiceException = IoTEventsDataServiceException;
993
+ exports.ListAlarmsCommand = ListAlarmsCommand;
994
+ exports.ListDetectorsCommand = ListDetectorsCommand;
995
+ exports.ResourceNotFoundException = ResourceNotFoundException;
996
+ exports.ServiceUnavailableException = ServiceUnavailableException;
997
+ exports.ThrottlingException = ThrottlingException;
998
+ exports.TriggerType = TriggerType;