@aws-sdk/client-iot-events-data 3.928.0 → 3.930.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class IoTEventsDataClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -110,12 +110,12 @@ class IoTEventsDataClient extends smithyClient.Client {
     }
 }
 
-class IoTEventsDataServiceException extends smithyClient.ServiceException {
+let IoTEventsDataServiceException$1 = class IoTEventsDataServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, IoTEventsDataServiceException.prototype);
     }
-}
+};
 
 const CustomerActionName = {
     ACKNOWLEDGE: "ACKNOWLEDGE",
@@ -153,7 +153,7 @@ const ErrorCode = {
     ServiceUnavailableException: "ServiceUnavailableException",
     ThrottlingException: "ThrottlingException",
 };
-class InternalFailureException extends IoTEventsDataServiceException {
+let InternalFailureException$1 = class InternalFailureException extends IoTEventsDataServiceException$1 {
     name = "InternalFailureException";
     $fault = "server";
     constructor(opts) {
@@ -164,8 +164,8 @@ class InternalFailureException extends IoTEventsDataServiceException {
         });
         Object.setPrototypeOf(this, InternalFailureException.prototype);
     }
-}
-class InvalidRequestException extends IoTEventsDataServiceException {
+};
+let InvalidRequestException$1 = class InvalidRequestException extends IoTEventsDataServiceException$1 {
     name = "InvalidRequestException";
     $fault = "client";
     constructor(opts) {
@@ -176,8 +176,8 @@ class InvalidRequestException extends IoTEventsDataServiceException {
         });
         Object.setPrototypeOf(this, InvalidRequestException.prototype);
     }
-}
-class ServiceUnavailableException extends IoTEventsDataServiceException {
+};
+let ServiceUnavailableException$1 = class ServiceUnavailableException extends IoTEventsDataServiceException$1 {
     name = "ServiceUnavailableException";
     $fault = "server";
     constructor(opts) {
@@ -188,8 +188,8 @@ class ServiceUnavailableException extends IoTEventsDataServiceException {
         });
         Object.setPrototypeOf(this, ServiceUnavailableException.prototype);
     }
-}
-class ThrottlingException extends IoTEventsDataServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends IoTEventsDataServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     constructor(opts) {
@@ -200,8 +200,8 @@ class ThrottlingException extends IoTEventsDataServiceException {
         });
         Object.setPrototypeOf(this, ThrottlingException.prototype);
     }
-}
-class ResourceNotFoundException extends IoTEventsDataServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends IoTEventsDataServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -212,548 +212,670 @@ class ResourceNotFoundException extends IoTEventsDataServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
-
-const se_BatchAcknowledgeAlarmCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/alarms/acknowledge");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        acknowledgeActionRequests: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_BatchDeleteDetectorCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/detectors/delete");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        detectors: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_BatchDisableAlarmCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/alarms/disable");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        disableActionRequests: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_BatchEnableAlarmCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/alarms/enable");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        enableActionRequests: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_BatchPutMessageCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/inputs/messages");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        messages: (_) => se_Messages(_, context),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_BatchResetAlarmCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/alarms/reset");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        resetActionRequests: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_BatchSnoozeAlarmCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/alarms/snooze");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        snoozeActionRequests: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_BatchUpdateDetectorCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/detectors");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        detectors: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeAlarmCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/alarms/{alarmModelName}/keyValues");
-    b.p("alarmModelName", () => input.alarmModelName, "{alarmModelName}", false);
-    const query = smithyClient.map({
-        [_kV]: [, input[_kV]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_DescribeDetectorCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/detectors/{detectorModelName}/keyValues");
-    b.p("detectorModelName", () => input.detectorModelName, "{detectorModelName}", false);
-    const query = smithyClient.map({
-        [_kV]: [, input[_kV]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListAlarmsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/alarms/{alarmModelName}");
-    b.p("alarmModelName", () => input.alarmModelName, "{alarmModelName}", false);
-    const query = smithyClient.map({
-        [_nT]: [, input[_nT]],
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListDetectorsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/detectors/{detectorModelName}");
-    b.p("detectorModelName", () => input.detectorModelName, "{detectorModelName}", false);
-    const query = smithyClient.map({
-        [_sN]: [, input[_sN]],
-        [_nT]: [, input[_nT]],
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const de_BatchAcknowledgeAlarmCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        errorEntries: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_BatchDeleteDetectorCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        batchDeleteDetectorErrorEntries: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_BatchDisableAlarmCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        errorEntries: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_BatchEnableAlarmCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        errorEntries: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_BatchPutMessageCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        BatchPutMessageErrorEntries: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_BatchResetAlarmCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        errorEntries: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_BatchSnoozeAlarmCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        errorEntries: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
 };
-const de_BatchUpdateDetectorCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        batchUpdateDetectorErrorEntries: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeAlarmCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        alarm: (_) => de_Alarm(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeDetectorCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        detector: (_) => de_Detector(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListAlarmsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        alarmSummaries: (_) => de_AlarmSummaries(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListDetectorsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        detectorSummaries: (_) => de_DetectorSummaries(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalFailureException":
-        case "com.amazonaws.ioteventsdata#InternalFailureException":
-            throw await de_InternalFailureExceptionRes(parsedOutput);
-        case "InvalidRequestException":
-        case "com.amazonaws.ioteventsdata#InvalidRequestException":
-            throw await de_InvalidRequestExceptionRes(parsedOutput);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.ioteventsdata#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.ioteventsdata#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.ioteventsdata#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(IoTEventsDataServiceException);
-const de_InternalFailureExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalFailureException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidRequestExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InvalidRequestException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ServiceUnavailableException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_Message = (input, context) => {
-    return smithyClient.take(input, {
-        inputName: [],
-        messageId: [],
-        payload: context.base64Encoder,
-        timestamp: smithyClient._json,
-    });
-};
-const se_Messages = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_Message(entry, context);
-    });
-};
-const de_Alarm = (output, context) => {
-    return smithyClient.take(output, {
-        alarmModelName: smithyClient.expectString,
-        alarmModelVersion: smithyClient.expectString,
-        alarmState: smithyClient._json,
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        keyValue: smithyClient.expectString,
-        lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        severity: smithyClient.expectInt32,
-    });
-};
-const de_AlarmSummaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_AlarmSummary(entry);
-    });
-    return retVal;
-};
-const de_AlarmSummary = (output, context) => {
-    return smithyClient.take(output, {
-        alarmModelName: smithyClient.expectString,
-        alarmModelVersion: smithyClient.expectString,
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        keyValue: smithyClient.expectString,
-        lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        stateName: smithyClient.expectString,
-    });
-};
-const de_Detector = (output, context) => {
-    return smithyClient.take(output, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        detectorModelName: smithyClient.expectString,
-        detectorModelVersion: smithyClient.expectString,
-        keyValue: smithyClient.expectString,
-        lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        state: (_) => de_DetectorState(_),
-    });
-};
-const de_DetectorState = (output, context) => {
-    return smithyClient.take(output, {
-        stateName: smithyClient.expectString,
-        timers: (_) => de_Timers(_),
-        variables: smithyClient._json,
-    });
-};
-const de_DetectorSummaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_DetectorSummary(entry);
-    });
-    return retVal;
-};
-const de_DetectorSummary = (output, context) => {
-    return smithyClient.take(output, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        detectorModelName: smithyClient.expectString,
-        detectorModelVersion: smithyClient.expectString,
-        keyValue: smithyClient.expectString,
-        lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        state: smithyClient._json,
-    });
-};
-const de_Timer = (output, context) => {
-    return smithyClient.take(output, {
-        name: smithyClient.expectString,
-        timestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_Timers = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Timer(entry);
-    });
-    return retVal;
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
+
+const _A = "Alarm";
+const _AAAR = "AcknowledgeAlarmActionRequest";
+const _AAARc = "AcknowledgeAlarmActionRequests";
+const _AAC = "AcknowledgeActionConfiguration";
+const _AS = "AlarmState";
+const _ASl = "AlarmSummary";
+const _ASla = "AlarmSummaries";
+const _BAA = "BatchAcknowledgeAlarm";
+const _BAAEE = "BatchAlarmActionErrorEntry";
+const _BAAEEa = "BatchAlarmActionErrorEntries";
+const _BAAR = "BatchAcknowledgeAlarmRequest";
+const _BAARa = "BatchAcknowledgeAlarmResponse";
+const _BDA = "BatchDisableAlarm";
+const _BDAR = "BatchDisableAlarmRequest";
+const _BDARa = "BatchDisableAlarmResponse";
+const _BDD = "BatchDeleteDetector";
+const _BDDEE = "BatchDeleteDetectorErrorEntry";
+const _BDDEEa = "BatchDeleteDetectorErrorEntries";
+const _BDDR = "BatchDeleteDetectorRequest";
+const _BDDRa = "BatchDeleteDetectorResponse";
+const _BEA = "BatchEnableAlarm";
+const _BEAR = "BatchEnableAlarmRequest";
+const _BEARa = "BatchEnableAlarmResponse";
+const _BPM = "BatchPutMessage";
+const _BPMEE = "BatchPutMessageErrorEntry";
+const _BPMEEa = "BatchPutMessageErrorEntries";
+const _BPMR = "BatchPutMessageRequest";
+const _BPMRa = "BatchPutMessageResponse";
+const _BRA = "BatchResetAlarm";
+const _BRAR = "BatchResetAlarmRequest";
+const _BRARa = "BatchResetAlarmResponse";
+const _BSA = "BatchSnoozeAlarm";
+const _BSAR = "BatchSnoozeAlarmRequest";
+const _BSARa = "BatchSnoozeAlarmResponse";
+const _BUD = "BatchUpdateDetector";
+const _BUDEE = "BatchUpdateDetectorErrorEntry";
+const _BUDEEa = "BatchUpdateDetectorErrorEntries";
+const _BUDR = "BatchUpdateDetectorRequest";
+const _BUDRa = "BatchUpdateDetectorResponse";
+const _CA = "CustomerAction";
+const _D = "Detector";
+const _DA = "DescribeAlarm";
+const _DAAR = "DisableAlarmActionRequest";
+const _DAARi = "DisableAlarmActionRequests";
+const _DAC = "DisableActionConfiguration";
+const _DAR = "DescribeAlarmRequest";
+const _DARe = "DescribeAlarmResponse";
+const _DD = "DescribeDetector";
+const _DDR = "DeleteDetectorRequest";
+const _DDRe = "DescribeDetectorRequest";
+const _DDRel = "DeleteDetectorRequests";
+const _DDRes = "DescribeDetectorResponse";
+const _DS = "DetectorState";
+const _DSD = "DetectorStateDefinition";
+const _DSS = "DetectorStateSummary";
+const _DSe = "DetectorSummary";
+const _DSet = "DetectorSummaries";
+const _EAAR = "EnableAlarmActionRequest";
+const _EAARn = "EnableAlarmActionRequests";
+const _EAC = "EnableActionConfiguration";
+const _IFE = "InternalFailureException";
+const _IRE = "InvalidRequestException";
+const _LA = "ListAlarms";
+const _LAR = "ListAlarmsRequest";
+const _LARi = "ListAlarmsResponse";
+const _LD = "ListDetectors";
+const _LDR = "ListDetectorsRequest";
+const _LDRi = "ListDetectorsResponse";
+const _M = "Message";
+const _Me = "Messages";
+const _RAAR = "ResetAlarmActionRequest";
+const _RAARe = "ResetAlarmActionRequests";
+const _RAC = "ResetActionConfiguration";
+const _RE = "RuleEvaluation";
+const _RNFE = "ResourceNotFoundException";
+const _SAAR = "SnoozeAlarmActionRequest";
+const _SAARn = "SnoozeAlarmActionRequests";
+const _SAC = "SnoozeActionConfiguration";
+const _SCC = "StateChangeConfiguration";
+const _SE = "SystemEvent";
+const _SRE = "SimpleRuleEvaluation";
+const _SUE = "ServiceUnavailableException";
+const _T = "Timer";
+const _TD = "TimerDefinition";
+const _TDi = "TimerDefinitions";
+const _TE = "ThrottlingException";
+const _TV = "TimestampValue";
+const _Ti = "Timers";
+const _UDR = "UpdateDetectorRequest";
+const _UDRp = "UpdateDetectorRequests";
+const _V = "Variable";
+const _VD = "VariableDefinition";
+const _VDa = "VariableDefinitions";
+const _Va = "Variables";
+const _a = "alarm";
+const _aAC = "acknowledgeActionConfiguration";
+const _aAR = "acknowledgeActionRequests";
+const _aMN = "alarmModelName";
+const _aMV = "alarmModelVersion";
+const _aN = "actionName";
+const _aS = "alarmState";
+const _aSl = "alarmSummaries";
+const _bDDEE = "batchDeleteDetectorErrorEntries";
+const _bUDEE = "batchUpdateDetectorErrorEntries";
+const _c = "client";
+const _cA = "customerAction";
+const _cT = "creationTime";
+const _d = "detectors";
+const _dAC = "disableActionConfiguration";
+const _dAR = "disableActionRequests";
+const _dMN = "detectorModelName";
+const _dMV = "detectorModelVersion";
+const _dS = "detectorSummaries";
+const _de = "detector";
+const _e = "error";
+const _eAC = "enableActionConfiguration";
+const _eAR = "enableActionRequests";
+const _eC = "errorCode";
+const _eE = "errorEntries";
+const _eM = "errorMessage";
+const _eT = "eventType";
+const _h = "http";
+const _hE = "httpError";
+const _hQ = "httpQuery";
+const _iN = "inputName";
+const _iPV = "inputPropertyValue";
 const _kV = "keyValue";
+const _lUT = "lastUpdateTime";
+const _m = "messages";
+const _mI = "messageId";
 const _mR = "maxResults";
+const _me = "message";
+const _n = "note";
 const _nT = "nextToken";
+const _na = "name";
+const _o = "operator";
+const _p = "payload";
+const _rAC = "resetActionConfiguration";
+const _rAR = "resetActionRequests";
+const _rE = "ruleEvaluation";
+const _rI = "requestId";
+const _s = "severity";
+const _sAC = "snoozeActionConfiguration";
+const _sAR = "snoozeActionRequests";
+const _sCC = "stateChangeConfiguration";
+const _sD = "snoozeDuration";
+const _sE = "systemEvent";
 const _sN = "stateName";
+const _sRE = "simpleRuleEvaluation";
+const _se = "server";
+const _sec = "seconds";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.ioteventsdata";
+const _st = "state";
+const _t = "timers";
+const _tIM = "timeInMillis";
+const _tT = "triggerType";
+const _tV = "thresholdValue";
+const _ti = "timestamp";
+const _v = "variables";
+const _va = "value";
+const n0 = "com.amazonaws.ioteventsdata";
+var AcknowledgeActionConfiguration = [3, n0, _AAC, 0, [_n], [0]];
+var AcknowledgeAlarmActionRequest = [3, n0, _AAAR, 0, [_rI, _aMN, _kV, _n], [0, 0, 0, 0]];
+var Alarm = [
+    3,
+    n0,
+    _A,
+    0,
+    [_aMN, _aMV, _kV, _aS, _s, _cT, _lUT],
+    [0, 0, 0, () => AlarmState, 1, 4, 4],
+];
+var AlarmState = [
+    3,
+    n0,
+    _AS,
+    0,
+    [_sN, _rE, _cA, _sE],
+    [0, () => RuleEvaluation, () => CustomerAction, () => SystemEvent],
+];
+var AlarmSummary = [
+    3,
+    n0,
+    _ASl,
+    0,
+    [_aMN, _aMV, _kV, _sN, _cT, _lUT],
+    [0, 0, 0, 0, 4, 4],
+];
+var BatchAcknowledgeAlarmRequest = [
+    3,
+    n0,
+    _BAAR,
+    0,
+    [_aAR],
+    [() => AcknowledgeAlarmActionRequests],
+];
+var BatchAcknowledgeAlarmResponse = [
+    3,
+    n0,
+    _BAARa,
+    0,
+    [_eE],
+    [() => BatchAlarmActionErrorEntries],
+];
+var BatchAlarmActionErrorEntry = [3, n0, _BAAEE, 0, [_rI, _eC, _eM], [0, 0, 0]];
+var BatchDeleteDetectorErrorEntry = [3, n0, _BDDEE, 0, [_mI, _eC, _eM], [0, 0, 0]];
+var BatchDeleteDetectorRequest = [3, n0, _BDDR, 0, [_d], [() => DeleteDetectorRequests]];
+var BatchDeleteDetectorResponse = [
+    3,
+    n0,
+    _BDDRa,
+    0,
+    [_bDDEE],
+    [() => BatchDeleteDetectorErrorEntries],
+];
+var BatchDisableAlarmRequest = [
+    3,
+    n0,
+    _BDAR,
+    0,
+    [_dAR],
+    [() => DisableAlarmActionRequests],
+];
+var BatchDisableAlarmResponse = [
+    3,
+    n0,
+    _BDARa,
+    0,
+    [_eE],
+    [() => BatchAlarmActionErrorEntries],
+];
+var BatchEnableAlarmRequest = [
+    3,
+    n0,
+    _BEAR,
+    0,
+    [_eAR],
+    [() => EnableAlarmActionRequests],
+];
+var BatchEnableAlarmResponse = [
+    3,
+    n0,
+    _BEARa,
+    0,
+    [_eE],
+    [() => BatchAlarmActionErrorEntries],
+];
+var BatchPutMessageErrorEntry = [3, n0, _BPMEE, 0, [_mI, _eC, _eM], [0, 0, 0]];
+var BatchPutMessageRequest = [3, n0, _BPMR, 0, [_m], [() => Messages]];
+var BatchPutMessageResponse = [
+    3,
+    n0,
+    _BPMRa,
+    0,
+    [_BPMEEa],
+    [() => BatchPutMessageErrorEntries],
+];
+var BatchResetAlarmRequest = [3, n0, _BRAR, 0, [_rAR], [() => ResetAlarmActionRequests]];
+var BatchResetAlarmResponse = [
+    3,
+    n0,
+    _BRARa,
+    0,
+    [_eE],
+    [() => BatchAlarmActionErrorEntries],
+];
+var BatchSnoozeAlarmRequest = [
+    3,
+    n0,
+    _BSAR,
+    0,
+    [_sAR],
+    [() => SnoozeAlarmActionRequests],
+];
+var BatchSnoozeAlarmResponse = [
+    3,
+    n0,
+    _BSARa,
+    0,
+    [_eE],
+    [() => BatchAlarmActionErrorEntries],
+];
+var BatchUpdateDetectorErrorEntry = [3, n0, _BUDEE, 0, [_mI, _eC, _eM], [0, 0, 0]];
+var BatchUpdateDetectorRequest = [3, n0, _BUDR, 0, [_d], [() => UpdateDetectorRequests]];
+var BatchUpdateDetectorResponse = [
+    3,
+    n0,
+    _BUDRa,
+    0,
+    [_bUDEE],
+    [() => BatchUpdateDetectorErrorEntries],
+];
+var CustomerAction = [
+    3,
+    n0,
+    _CA,
+    0,
+    [_aN, _sAC, _eAC, _dAC, _aAC, _rAC],
+    [
+        0,
+        () => SnoozeActionConfiguration,
+        () => EnableActionConfiguration,
+        () => DisableActionConfiguration,
+        () => AcknowledgeActionConfiguration,
+        () => ResetActionConfiguration,
+    ],
+];
+var DeleteDetectorRequest = [3, n0, _DDR, 0, [_mI, _dMN, _kV], [0, 0, 0]];
+var DescribeAlarmRequest = [
+    3,
+    n0,
+    _DAR,
+    0,
+    [_aMN, _kV],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _kV,
+            },
+        ],
+    ],
+];
+var DescribeAlarmResponse = [3, n0, _DARe, 0, [_a], [() => Alarm]];
+var DescribeDetectorRequest = [
+    3,
+    n0,
+    _DDRe,
+    0,
+    [_dMN, _kV],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _kV,
+            },
+        ],
+    ],
+];
+var DescribeDetectorResponse = [3, n0, _DDRes, 0, [_de], [() => Detector]];
+var Detector = [
+    3,
+    n0,
+    _D,
+    0,
+    [_dMN, _kV, _dMV, _st, _cT, _lUT],
+    [0, 0, 0, () => DetectorState, 4, 4],
+];
+var DetectorState = [3, n0, _DS, 0, [_sN, _v, _t], [0, () => Variables, () => Timers]];
+var DetectorStateDefinition = [
+    3,
+    n0,
+    _DSD,
+    0,
+    [_sN, _v, _t],
+    [0, () => VariableDefinitions, () => TimerDefinitions],
+];
+var DetectorStateSummary = [3, n0, _DSS, 0, [_sN], [0]];
+var DetectorSummary = [
+    3,
+    n0,
+    _DSe,
+    0,
+    [_dMN, _kV, _dMV, _st, _cT, _lUT],
+    [0, 0, 0, () => DetectorStateSummary, 4, 4],
+];
+var DisableActionConfiguration = [3, n0, _DAC, 0, [_n], [0]];
+var DisableAlarmActionRequest = [3, n0, _DAAR, 0, [_rI, _aMN, _kV, _n], [0, 0, 0, 0]];
+var EnableActionConfiguration = [3, n0, _EAC, 0, [_n], [0]];
+var EnableAlarmActionRequest = [3, n0, _EAAR, 0, [_rI, _aMN, _kV, _n], [0, 0, 0, 0]];
+var InternalFailureException = [
+    -3,
+    n0,
+    _IFE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_me],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalFailureException, InternalFailureException$1);
+var InvalidRequestException = [
+    -3,
+    n0,
+    _IRE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_me],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidRequestException, InvalidRequestException$1);
+var ListAlarmsRequest = [
+    3,
+    n0,
+    _LAR,
+    0,
+    [_aMN, _nT, _mR],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListAlarmsResponse = [3, n0, _LARi, 0, [_aSl, _nT], [() => AlarmSummaries, 0]];
+var ListDetectorsRequest = [
+    3,
+    n0,
+    _LDR,
+    0,
+    [_dMN, _sN, _nT, _mR],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _sN,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListDetectorsResponse = [3, n0, _LDRi, 0, [_dS, _nT], [() => DetectorSummaries, 0]];
+var Message = [3, n0, _M, 0, [_mI, _iN, _p, _ti], [0, 0, 21, () => TimestampValue]];
+var ResetActionConfiguration = [3, n0, _RAC, 0, [_n], [0]];
+var ResetAlarmActionRequest = [3, n0, _RAAR, 0, [_rI, _aMN, _kV, _n], [0, 0, 0, 0]];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_me],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var RuleEvaluation = [3, n0, _RE, 0, [_sRE], [() => SimpleRuleEvaluation]];
+var ServiceUnavailableException = [
+    -3,
+    n0,
+    _SUE,
+    {
+        [_e]: _se,
+        [_hE]: 503,
+    },
+    [_me],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceUnavailableException, ServiceUnavailableException$1);
+var SimpleRuleEvaluation = [3, n0, _SRE, 0, [_iPV, _o, _tV], [0, 0, 0]];
+var SnoozeActionConfiguration = [3, n0, _SAC, 0, [_sD, _n], [1, 0]];
+var SnoozeAlarmActionRequest = [
+    3,
+    n0,
+    _SAAR,
+    0,
+    [_rI, _aMN, _kV, _n, _sD],
+    [0, 0, 0, 0, 1],
+];
+var StateChangeConfiguration = [3, n0, _SCC, 0, [_tT], [0]];
+var SystemEvent = [3, n0, _SE, 0, [_eT, _sCC], [0, () => StateChangeConfiguration]];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_me],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var Timer = [3, n0, _T, 0, [_na, _ti], [0, 4]];
+var TimerDefinition = [3, n0, _TD, 0, [_na, _sec], [0, 1]];
+var TimestampValue = [3, n0, _TV, 0, [_tIM], [1]];
+var UpdateDetectorRequest = [
+    3,
+    n0,
+    _UDR,
+    0,
+    [_mI, _dMN, _kV, _st],
+    [0, 0, 0, () => DetectorStateDefinition],
+];
+var Variable = [3, n0, _V, 0, [_na, _va], [0, 0]];
+var VariableDefinition = [3, n0, _VD, 0, [_na, _va], [0, 0]];
+var IoTEventsDataServiceException = [-3, _sm, "IoTEventsDataServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(IoTEventsDataServiceException, IoTEventsDataServiceException$1);
+var AcknowledgeAlarmActionRequests = [1, n0, _AAARc, 0, () => AcknowledgeAlarmActionRequest];
+var AlarmSummaries = [1, n0, _ASla, 0, () => AlarmSummary];
+var BatchAlarmActionErrorEntries = [1, n0, _BAAEEa, 0, () => BatchAlarmActionErrorEntry];
+var BatchDeleteDetectorErrorEntries = [1, n0, _BDDEEa, 0, () => BatchDeleteDetectorErrorEntry];
+var BatchPutMessageErrorEntries = [1, n0, _BPMEEa, 0, () => BatchPutMessageErrorEntry];
+var BatchUpdateDetectorErrorEntries = [1, n0, _BUDEEa, 0, () => BatchUpdateDetectorErrorEntry];
+var DeleteDetectorRequests = [1, n0, _DDRel, 0, () => DeleteDetectorRequest];
+var DetectorSummaries = [1, n0, _DSet, 0, () => DetectorSummary];
+var DisableAlarmActionRequests = [1, n0, _DAARi, 0, () => DisableAlarmActionRequest];
+var EnableAlarmActionRequests = [1, n0, _EAARn, 0, () => EnableAlarmActionRequest];
+var Messages = [1, n0, _Me, 0, () => Message];
+var ResetAlarmActionRequests = [1, n0, _RAARe, 0, () => ResetAlarmActionRequest];
+var SnoozeAlarmActionRequests = [1, n0, _SAARn, 0, () => SnoozeAlarmActionRequest];
+var TimerDefinitions = [1, n0, _TDi, 0, () => TimerDefinition];
+var Timers = [1, n0, _Ti, 0, () => Timer];
+var UpdateDetectorRequests = [1, n0, _UDRp, 0, () => UpdateDetectorRequest];
+var VariableDefinitions = [1, n0, _VDa, 0, () => VariableDefinition];
+var Variables = [1, n0, _Va, 0, () => Variable];
+var BatchAcknowledgeAlarm = [
+    9,
+    n0,
+    _BAA,
+    {
+        [_h]: ["POST", "/alarms/acknowledge", 202],
+    },
+    () => BatchAcknowledgeAlarmRequest,
+    () => BatchAcknowledgeAlarmResponse,
+];
+var BatchDeleteDetector = [
+    9,
+    n0,
+    _BDD,
+    {
+        [_h]: ["POST", "/detectors/delete", 200],
+    },
+    () => BatchDeleteDetectorRequest,
+    () => BatchDeleteDetectorResponse,
+];
+var BatchDisableAlarm = [
+    9,
+    n0,
+    _BDA,
+    {
+        [_h]: ["POST", "/alarms/disable", 202],
+    },
+    () => BatchDisableAlarmRequest,
+    () => BatchDisableAlarmResponse,
+];
+var BatchEnableAlarm = [
+    9,
+    n0,
+    _BEA,
+    {
+        [_h]: ["POST", "/alarms/enable", 202],
+    },
+    () => BatchEnableAlarmRequest,
+    () => BatchEnableAlarmResponse,
+];
+var BatchPutMessage = [
+    9,
+    n0,
+    _BPM,
+    {
+        [_h]: ["POST", "/inputs/messages", 200],
+    },
+    () => BatchPutMessageRequest,
+    () => BatchPutMessageResponse,
+];
+var BatchResetAlarm = [
+    9,
+    n0,
+    _BRA,
+    {
+        [_h]: ["POST", "/alarms/reset", 202],
+    },
+    () => BatchResetAlarmRequest,
+    () => BatchResetAlarmResponse,
+];
+var BatchSnoozeAlarm = [
+    9,
+    n0,
+    _BSA,
+    {
+        [_h]: ["POST", "/alarms/snooze", 202],
+    },
+    () => BatchSnoozeAlarmRequest,
+    () => BatchSnoozeAlarmResponse,
+];
+var BatchUpdateDetector = [
+    9,
+    n0,
+    _BUD,
+    {
+        [_h]: ["POST", "/detectors", 200],
+    },
+    () => BatchUpdateDetectorRequest,
+    () => BatchUpdateDetectorResponse,
+];
+var DescribeAlarm = [
+    9,
+    n0,
+    _DA,
+    {
+        [_h]: ["GET", "/alarms/{alarmModelName}/keyValues", 200],
+    },
+    () => DescribeAlarmRequest,
+    () => DescribeAlarmResponse,
+];
+var DescribeDetector = [
+    9,
+    n0,
+    _DD,
+    {
+        [_h]: ["GET", "/detectors/{detectorModelName}/keyValues", 200],
+    },
+    () => DescribeDetectorRequest,
+    () => DescribeDetectorResponse,
+];
+var ListAlarms = [
+    9,
+    n0,
+    _LA,
+    {
+        [_h]: ["GET", "/alarms/{alarmModelName}", 200],
+    },
+    () => ListAlarmsRequest,
+    () => ListAlarmsResponse,
+];
+var ListDetectors = [
+    9,
+    n0,
+    _LD,
+    {
+        [_h]: ["GET", "/detectors/{detectorModelName}", 200],
+    },
+    () => ListDetectorsRequest,
+    () => ListDetectorsResponse,
+];
 
 class BatchAcknowledgeAlarmCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotColumboDataService", "BatchAcknowledgeAlarm", {})
     .n("IoTEventsDataClient", "BatchAcknowledgeAlarmCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchAcknowledgeAlarmCommand)
-    .de(de_BatchAcknowledgeAlarmCommand)
+    .sc(BatchAcknowledgeAlarm)
     .build() {
 }
 
@@ -761,16 +883,11 @@ class BatchDeleteDetectorCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotColumboDataService", "BatchDeleteDetector", {})
     .n("IoTEventsDataClient", "BatchDeleteDetectorCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchDeleteDetectorCommand)
-    .de(de_BatchDeleteDetectorCommand)
+    .sc(BatchDeleteDetector)
     .build() {
 }
 
@@ -778,16 +895,11 @@ class BatchDisableAlarmCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotColumboDataService", "BatchDisableAlarm", {})
     .n("IoTEventsDataClient", "BatchDisableAlarmCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchDisableAlarmCommand)
-    .de(de_BatchDisableAlarmCommand)
+    .sc(BatchDisableAlarm)
     .build() {
 }
 
@@ -795,16 +907,11 @@ class BatchEnableAlarmCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotColumboDataService", "BatchEnableAlarm", {})
     .n("IoTEventsDataClient", "BatchEnableAlarmCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchEnableAlarmCommand)
-    .de(de_BatchEnableAlarmCommand)
+    .sc(BatchEnableAlarm)
     .build() {
 }
 
@@ -812,16 +919,11 @@ class BatchPutMessageCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotColumboDataService", "BatchPutMessage", {})
     .n("IoTEventsDataClient", "BatchPutMessageCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchPutMessageCommand)
-    .de(de_BatchPutMessageCommand)
+    .sc(BatchPutMessage)
     .build() {
 }
 
@@ -829,16 +931,11 @@ class BatchResetAlarmCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotColumboDataService", "BatchResetAlarm", {})
     .n("IoTEventsDataClient", "BatchResetAlarmCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchResetAlarmCommand)
-    .de(de_BatchResetAlarmCommand)
+    .sc(BatchResetAlarm)
     .build() {
 }
 
@@ -846,16 +943,11 @@ class BatchSnoozeAlarmCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotColumboDataService", "BatchSnoozeAlarm", {})
     .n("IoTEventsDataClient", "BatchSnoozeAlarmCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchSnoozeAlarmCommand)
-    .de(de_BatchSnoozeAlarmCommand)
+    .sc(BatchSnoozeAlarm)
     .build() {
 }
 
@@ -863,16 +955,11 @@ class BatchUpdateDetectorCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotColumboDataService", "BatchUpdateDetector", {})
     .n("IoTEventsDataClient", "BatchUpdateDetectorCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchUpdateDetectorCommand)
-    .de(de_BatchUpdateDetectorCommand)
+    .sc(BatchUpdateDetector)
     .build() {
 }
 
@@ -880,16 +967,11 @@ class DescribeAlarmCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotColumboDataService", "DescribeAlarm", {})
     .n("IoTEventsDataClient", "DescribeAlarmCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeAlarmCommand)
-    .de(de_DescribeAlarmCommand)
+    .sc(DescribeAlarm)
     .build() {
 }
 
@@ -897,16 +979,11 @@ class DescribeDetectorCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotColumboDataService", "DescribeDetector", {})
     .n("IoTEventsDataClient", "DescribeDetectorCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeDetectorCommand)
-    .de(de_DescribeDetectorCommand)
+    .sc(DescribeDetector)
     .build() {
 }
 
@@ -914,16 +991,11 @@ class ListAlarmsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotColumboDataService", "ListAlarms", {})
     .n("IoTEventsDataClient", "ListAlarmsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListAlarmsCommand)
-    .de(de_ListAlarmsCommand)
+    .sc(ListAlarms)
     .build() {
 }
 
@@ -931,16 +1003,11 @@ class ListDetectorsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotColumboDataService", "ListDetectors", {})
     .n("IoTEventsDataClient", "ListDetectorsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListDetectorsCommand)
-    .de(de_ListDetectorsCommand)
+    .sc(ListDetectors)
     .build() {
 }
 
@@ -985,14 +1052,14 @@ exports.DescribeAlarmCommand = DescribeAlarmCommand;
 exports.DescribeDetectorCommand = DescribeDetectorCommand;
 exports.ErrorCode = ErrorCode;
 exports.EventType = EventType;
-exports.InternalFailureException = InternalFailureException;
-exports.InvalidRequestException = InvalidRequestException;
+exports.InternalFailureException = InternalFailureException$1;
+exports.InvalidRequestException = InvalidRequestException$1;
 exports.IoTEventsData = IoTEventsData;
 exports.IoTEventsDataClient = IoTEventsDataClient;
-exports.IoTEventsDataServiceException = IoTEventsDataServiceException;
+exports.IoTEventsDataServiceException = IoTEventsDataServiceException$1;
 exports.ListAlarmsCommand = ListAlarmsCommand;
 exports.ListDetectorsCommand = ListDetectorsCommand;
-exports.ResourceNotFoundException = ResourceNotFoundException;
-exports.ServiceUnavailableException = ServiceUnavailableException;
-exports.ThrottlingException = ThrottlingException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
+exports.ServiceUnavailableException = ServiceUnavailableException$1;
+exports.ThrottlingException = ThrottlingException$1;
 exports.TriggerType = TriggerType;